perm filename LINED[KA,SYS] blob sn#472062 filedate 1976-08-07 generic text, type C, neo UTF8
COMMENT ⊗   VALID 00042 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00005 00002	BEGIN LINED
C00007 00003	GLOBAL LINE,KBDCHN,CHR
C00011 00004	KBDEDP PTLPUT PTLPU1 PTLPCC KBDED KBDX1 KBDX2
C00016 00005	KBDBEG KBDBG1 NOINIT LE20 LE21 LE22 LE23
C00022 00006	LECCN LFLUSH
C00023 00007	LEC1 LECB
C00025 00008	LE2 LE2CR LE2X LE2XA LE2XB
C00029 00009	LE2A LEOVS LEOVD LEINS LEINS1 LEOVSC
C00033 00010	PUTLF PUTCHR PUTCH1 PUTCH2 PUTCH3
C00036 00011	INSTAB INST1 INSCHR INSCH1 LEINSW INSW1 INST2 INST3 INST4
C00040 00012	GCOLL GCOLL1 GCOLL2 GCOLL3 GCOLL4 PCHK 
C00043 00013	LECT LECSP CKNFOR LECX LECX1 MVX1 MVX1A SHIFT2 CKNFO2
C00047 00014	LECFF LEBS BSP1 BSP2 BSP3
C00050 00015	LECI INSP1 LECD SRCHCR DMDELE
C00053 00016	ADJNTB ADJTB LECD4A LECD6 LECD5 LECD5A
C00056 00017	SEARCH RESRCH SRCHL GETEM GETEM1 GETEM2 GETEM0
C00059 00018	LEDESC ESCR ESCP ESCZ
C00061 00019	TTYESC
C00063 00020	CLEAR LECLR LECLR2
C00065 00021	ESCC ESCC0 ESCC1 ESCC2 BRKP ESCG ESCL ESCHX
C00067 00022	ESCJ ESCE ESCU ESCY ESCY1 ESCN
C00069 00023	ESCH UNHIDE ESCO ESCF
C00071 00024	ESCW ESCW2 ESCW1 ESCQ ESCQY ESCQX
C00075 00025	ESCI ESCX ESCX1
C00077 00026	FNTAB FNT1 FNT2 FNT3 FNT4 FNT5
C00079 00027	MOVEIT MVFOR MVBAK MVA MVA1 MVA2
C00083 00028	INIT2 INIT4 INIT4A INIT4B CRKILL
C00086 00029	INITIT INIT3 INIT1
C00089 00030	LACTIV ACTIV1 PTLLX ACTNH ACTNH0
C00092 00031	ACTIV3 ACTIV4 ACTIV9 ACTIVL ACTIVM ACTIV6 ACTIVQ ACTIVR ACTIVS
C00097 00032	ACTIV2 ACTIV7 ACTIV8 ACTI10
C00099 00033	ECHOCB ECHO SHIFT SHIFTR SHIFTL
C00101 00034	PTL7W9 PTLLED (PTLOAD) EPTL1 EPTL2 PTLL0 PTLL2 PTLL3 PTLL4 PTLL09 PTLLX0 PTLLX1 PTLLX9
C00106 00035	QLECUR QLETXT QLETX2
C00108 00036	MAKECR LEFIX MAKEC1
C00110 00037	MAKE12 MAKE23 MAKE22 MAKE20 MAKE21 MAKEC8 MAKEC9 MAKEC7 MAKE10 MAKE24
C00113 00038	MAKEC2 MAKEC6 MAKE17 MAKE18
C00115 00039	MAKEC3 MAKEC4 MAKE16
C00118 00040	MAKE15 MAKE13 MAKE14 MAKEC5
C00120 00041	MAKE11 MAKINS
C00121 00042	PUTDMC GETLEQ QUODMC PUTDM2 QU2DMC QU2DM2 QU2DM3
C00125 ENDMK
C⊗;
BEGIN LINED

COMMENT ⊗  THIS IS THE INCREDIBLE INTRA-LINE EDITOR. ITS FEATURES ARE:

	CTRL SPACE-- MOVE FORWARD THROUGH LINE.
	CTRL BS-- MOVE BACKWARD.
	BS -- MOVE BACKWARD, DELETING (END OF LINE ONLY).
	META BS -- MOVE BACKWARD, DELETING.
	CTRL I	-- ENTER INSERT MODE (MIDDLE OF LINE ONLY).
	CTRL D -- DELETE FORWARD (MIDDLE OF LINE ONLY).
	CTRL TAB -- MOVE TO END OF LINE.
	CTRL FORM -- MOVE TO BEGINNING OF LINE.
	CLEAR -- DELETE ENTIRE LINE.
	CTRL S<ANY CHR.> -- MOVE POINTER RIGHT TO NEXT OCCURRENCE OF <ANY CHR.>.
		IF <ANY CHR> IS CR, MOVES TO END OF LINE
	CTRL K<ANY CHR.> -- DELETE RIGHT TO NEXT OCCURRENCE OF <ANY CHR.>.
		IF <ANY CHR> IS CR, KILLS TO END OF LINE
	CTRL R -- REPEAT LAST CTRL S OR CTRL K COMMAND GIVEN, USING SAME CHAR.

	CTRL CR -- (ONLY AT START OF LINE OR AFTER CLEAR) RETRIEVES THE
		LAST LINE TYPED IN.

	META<ANY CHR.> -- INSERT <ANY CHR.> IN FRONT OF CURSOR (MIDDLE OF LINE ONLY)

ANY COMMAND MAY BE PRECEDED BY A REPEAT NUMBER (TYPED WITH CTRL KEY).
    FOR EXAMPLE, CTRL 9 CTRL BS MOVES THE POINTER BACK 9 CHARACTERS.
ANY CTRL COMMAND LEAVES INSERT MODE, AS DOES ANY META<CHAR>.

WHAT COULD BE MORE WONDERFUL ??
⊗

GLOBAL LINE,KBDCHN,CHR

;J←ITEM ;USED TO BE I←ITEM

CBIT1←←1	;CTRL BIT 1.
CBIT2←←2	;CTRL BIT 2.
EOLCHR←←12	;LINE FEED TERMINATES THE LINE IN THE BUFFER.

	;;STATUS BITS (LEFT HALF OF J).

↑WTFLAG←←1	;WAITING FOR PRGM. TO SWALLOW LAST LINE.
EOLBT←←2	;AT END OF LINE.
INSBT←←4	;INSERT MODE (MIDDLE OF LINE).
TABB←←10	;LOCATION OF NEXT TAB IN NTABPT, SIZE IN NTABCT.
NOTABB←←20	;NO TAB BETWEEN CURRENT POS. AND END OF LINE.
DMDAMN←←40	;Extra hard case--absolutely must redraw whole LE for now
	;DMDAMN is set: if LE has ≤ 1 char in it, or if CLEAR or ESC R typed, or
	;		if we have to delete anything when line wraps around, or
	;		if we have to adjust a tab somewhere later in the line.
XTABBT←←100	;WE ARE INSIDE A TAB IN GETEM.
;;;SHLDRB←←200	;Loser wants to see every chr. we see.
DMHARD←←200	;Case requires insertions--will redraw all if line wraps around.
	;DMHARD is also used as a temporary flag to LECD to suppress DM deletions.
SRCHBT←←400	;CTRL1 S SEEN, NEXT CHR. IS SEARCH ARGUMENT.
KILLBT←←1000	;CTRL1 K SEEN....
REEDBT←←2000	;WE ARE RE-EDITING A LINE (AFTER A CTRL1 CR).
NOCRBT←←4000	;WE SHOULD NOT PUT ANOTHER CR INTO THIS LINE.
NOTEXT←←10000	; THIS BIT MEANS THE TEXT HAS NOT BEEN CHANGED, JUST THE CURSOR
NOTFR←←20000	; MEANS THAT NO TRANSFER AT ALL SHOULD TAKE PLACE
CRBIT←←40000	; USED TO SKIP OVER CRLF IN MIDDLE OF LINE IN GETEM
	;CRBIT is also used as flag to INSTAB meaning overtyping a TAB
NOBRBT←←100000	; MEANS LINE HAS NOT BEEN BROKEN UP. LONG LINES ONLY.
ACTNOW←←200000	; MEANS WE SHOULD ACTIVATE NOW

;; NOW SOME DISPLAY OPCODES AND MACROS FOR GENERATING DP INSTRS.

DISJMP←←20	;DP JMP INSTR. OPCODE.
DISJMS←←4	; JMS (STORES TWO WORDS)
DISJSR←←24	; STORES ONLY RETURN ADDR.
DISRST←←14	;RESTORE.
DISSEL←←10	;SELECT.
DISNOP←←12	;ACTUALLY TSS, BUT A GOOD NOP WITH ALL BITS OFF.

DEFINE LVW(X,Y,TYPE,MODE,BRT,SIZ)	;ASSEMBLES A LONG VECTOR.
  { MVW1 (MODE,TYPE,BRT,SIZ)	;TWIDDLE PARAMS.
	BYTE (11)<X>,<Y>(3)B,S(2)MD,TT(3)3 }	;ASSEMBLE INSTR.
DEFINE MVW1 (M,T,BRT,SIZ)
 {IFIDN {M}{A}{MD←←1;}MD←←0	;MODE = `A' FOR ABSOLUTE.
  IFIDN {T}{I}{TT←←2;}TT←←0	;TYPE = `I' FOR INVISIBLE.
  IFIDN {BRT}{}{B←←0;}B←←BRT	;BRT = 0 IF OMITTED.
  IFIDN {SIZ}{}{S←←0;}S←←SIZ	;SAME FOR SIZ.
}

↑↑XDEL:	14B10	;X-SIZE OF A SIZE 2 CHARACTER, POSTIONED AT THE X-FIELD.
XDEL2:	14B11	;ONE HALF OF ABOVE.
;KBDEDP PTLPUT PTLPU1 PTLPCC KBDED KBDX1 KBDX2

COMMENT ⊗ KBDED IS CALLED AT UUO OR INTERRUPT LEVELS FROM RECINT,
          WITH CHR CONTAINING THE CHAR TO BE CONSIDERED WITH ITS
          CTRL BITS IN PLACE.
        UCHN CONTAINS JUST THE CTRL BITS, RIGHT JUSTIFIED.
        DSER CONTAINS THE LOWER-CASE VERSION OF THE CHARACTER IN CHR.
        DDB AND LINE ARE SETUP TO THE RIGHT TTY, AS IS IOS.
        PROG, IOS, AND UUO ARE PRESERVED BY KBDED. 
⊗

↑KBDEDP:
	TLNN IOS,PTLIP		;IF NOT PTLOAD IN PROGRESS,
	JRST KBDED		;  THEN DO THE LINE EDITOR BIT
PTLPUT:	TRNE CHR,10000
	POPJ P,			;DON'T TRY TO STORE ESCAPE COMMANDS
	TRNN CHR,177
	JRST PTLPCC		;USER TYPING CALL DURING PTLOAD
	MOVE TAC,PTLPTR		;GET BPT TO STORE INTO
	CAME TAC,[POINT 9,PTLBUF+PTLBUL-1,26]
PTLPU1:	IDPB CHR,PTLPTR		;OK, DEPOSIT CHAR
	POPJ P,

PTLPCC:	SETZM PTLBUF		;HE TYPED CALL, FLUSH ANY OTHER TYPEAHEAD
	MOVE TAC,[PTLBUF,,PTLBUF+1]
	BLT TAC,PTLBUF+PTLBUL-1
	MOVE TAC,[POINT 9,PTLBUF]
	MOVEM TAC,PTLPTR
	MOVEM TAC,PTLTKR	;IN CASE HE'S READING THE BUFFER BUFFER ALREADY
	JRST PTLPU1

↑KBDED:
IFN FTOIKB, <	CAIN CHR,10000		;<CTRL 2> LINE FEED IS FOR ↑O.
		; HANGOVER FOR III KEYBOARDS
		JRST CONTOB		;CONTOB IS IN TTEDIT. >
	MOVE DAT,LINE		;GET DPY NO. AND LINTAB BITS INTO DAT.
	MOVE J,LETAB(DAT)	;LOAD J WITH PTR TO CONTROL BLOCK AND BITS
	TLZ J,NOTEXT!NOTFR!CRBIT!DMHARD!DMDAMN
	SETOM LEINV(J)		; SET BUFFER INVALID
	SETOM LEACT(J)		; MAKE SURE WE STICK AROUND FOR ANOTHER MINUTE
;;;	TLNE J,SHLDRB		;Loser looking over our shoulder ?
;;;	PUSHJ P,LSRSEE		;Hold up chr. for him to see. Hope he likes it.
	PUSHJ P,KBDBEG		; DO LINE EDITOR BIT
	SETZM LEINV(J)
IFN FTINCL,<
	MOVE AC1,FCPOS(J)	;Number of chars in line
	SOJG AC1,.+2
	TLO J,DMDAMN		;Force redrawing whole line if less than two chars
>;FTINCL
	TLZE J,NOTFR		; WAS THIS A SILENT COMMAND?
	JRST KBDX1		; YES, JUST LEAVE QUIETLY
	TLNE J,NOTEXT		; HAS THE TEXT BEEN CHANGED?
	PUSHJ P,QLECUR		; NO, JUST UPDATE THE CURSOR
	TLZE J,NOTEXT
KBDX1:	SKIPE LEWAKE(J)		; DID WE CAUSE A TRANSFER TO ABORT?
	PUSHJ P,QLETX2		; YES, UPDATE BOTH
	SETZM LEWAKE(J)		; CLEAR ABORT FLAG
	MOVE AC1,PRGNUM(J)	; PICK UP TTY NUMBER
	HLLM J,LETAB(AC1)	; STORE FINAL BITS
IFN FTINCL,<
	MOVE DAT,J		;Dpy header in DAT for STRTDM
	PUSH P,IOS
	TLNE AC1,DMLIN
	PUSHJ P,STRTDM		;Make sure incremental LE gets output
	POP P,IOS
	MOVE J,DAT
>;FTINCL
	TLNE J,WTFLAG		;ARE WE CURRENTLY ACTIVATING SOMETHING?
	POPJ P,			;YES, SNEAK WILL GET WOKEN UP LATER!
	TLNE IOS,SNKWAT		; IN SNEAK WAIT?
	SKIPG CCPOS(J)		; ANYTHING FOR HIM TO SEE?
	POPJ P,
KBDX2:	MOVE IOS,[XWD TTYIOW!SNKWAT,IOACT]	;YES, CLEAR FLAGS
	ANDCAB IOS,DEVIOS(DDB)
	JRST STTIOD		;BRING HIM OUT OF WAIT

REPEAT 0,<	;POOLE MODE FLUSHED!!!
LSRSEE:	PUSH P,DAT
	MOVEI DAT,TTIBUF(DDB)
	PUSHJ P,PUTCHI		;Put chr. in loser's input buffer.
	JFCL			;Buffer full. Loser loses.
	MOVE AC1,TIFCTR(DDB)
	CAIG AC1,TTICHR/4	;Is his buffer getting full ?
	TLNN IOS,TTYIOW		;Is he waiting for input ?
	JRST LSRSEX		;No.
	PUSHJ P,SYNCHA		;Prepare to activate loser.
	PUSHJ P,KBDX2		;Wake him up.
LSRSEX:	POP P,DAT
	POPJ P,
>
;KBDBEG KBDBG1 NOINIT LE20 LE21 LE22 LE23

KBDBEG:
;DONT	MOVE AC2,TIME		; PICK UP TIME OF DAY
;SAVE	SKIPN DPKTIM(J)		; HAS THE TIME BEEN STORED YET?
;TIME	MOVEM AC2,DPKTIM(J)	; NO, DO SO
	SKIPE III(J)
	JRST KBDBG1
	MOVE AC3,CURPP(J)
	MOVE AC2,DPHPOS(AC3)
	SKIPGE LEPOS(J)
	TDZA AC2,AC2
	ADD AC2,LNLNGT(AC3)
	MOVEM AC2,PPHPOS(J)
KBDBG1:	TRNE CHR,10000
	JRST LEDESC		;<ESC>SOMETHING
	TRNN CHR,177		;IS THIS MAYBE A CALL?
	JRST LECCN		;A CALL WILL BE A NULL NOW.
	JUMPL J,NOINIT		;IS THIS THE FIRST CHAR OF A LINE?
	TLNE J,WTFLAG		;YES, IS LAST LINE IN USER BUFFER YET?
	JRST TPOPJ		;NO, JUST IGNORE HIM
	PUSHJ P,INIT2		;CLEANSE THE WORLD
NOINIT:	ANDI CHR,177		;REMOVE CTRL BITS FROM CHR.
	CAIL CHR,"a"		;IS IT A LOWER CASE LETTER ?
	CAILE CHR,"z"
	JRST LE20		;NO.
;	TLNN IOS,TPMON		;YES. IF MONITOR MODE OR
	TLNN DAT,FCS		; NOT FULL CHAR. SET MODE,
	SUBI CHR,40		; CONVERT TO UPPER CASE.
LE20:	TLZE J,SRCHBT		;WAS LAST CHR. AN S OR K COMMAND ?
	JRST SEARCH		;YES.
	TLNE IOS,TPMON		;IGNORE ALLACT AND BSACT IN MONITOR MODE
	JRST LE23
	MOVEI AC2,ALLACT	;SETACT BIT TO ACTIVATE ON ALL BUCKY BITS AND BS
	TDNE AC2,ACTMOD(DDB)
	TLNE J,REEDBT		;IGNORE ALLACT IF RE-EDITING A LINE
	JRST LE21		;NO SPECIAL TREATMENT
	JUMPG UCHN,LE2		;GIVE HIM CHAR WITH SOME BUCKY BITS
	JRST LE22

LE21:	MOVEI AC2,BSACT
	SKIPN FCPOS(J)		;IGNORE BSACT UNLESS EMPTY LINE
	TDNN AC2,ACTMOD(DDB)
	JRST LE23
LE22:	CAIN CHR,177
	JRST LE2		;GIVE HIM THE BS
LE23:	CAIE CHR,177		;IF IT'S A BACKSPACE, PRETEND IT HAS CTRL 1.
	CAIN UCHN,CBIT1		;DO WE HAVE CTRL 1 ONLY ?
	TLNE IOS,DDTM		;YES. IS EDITOR DISABLED ?
	JRST LE2		;NOT A COMMAND. GO PUT IT IN BUFFER.
	CAIG CHR,"9"		;CTRL1 ONLY IS ON.  IS IT A DIGIT ?
	CAIGE CHR,"0"
	JRST LEC1		;NO. CTRL1 LETTER, OR RUBOUT
	MOVE AC1,NUMARG(J)	;YES. CTRL NUMBERS ARE PART OF REPEAT ARGUMENT.
	IMULI AC1,=10		;DO DECIMAL CONVERSION.
	ADDI AC1,-"0"(CHR)
	ANDI AC1,777		;DON'T LET IT GET TOO BIG.
	MOVEM AC1,NUMARG(J)
	POPJ P,
;LECCN LFLUSH

LECCN:	PUSH P,J		; SAVE THE DPY PROGRAM HEADER ADDRESS
	PUSHJ P,RECINB
	POP P,J
	HRRZ DAT,LINE		; RECINB CLOBBERS THIS
	SETZ AC1,
	EXCH AC1,DPHOLD(J)
	JUMPE AC1,LFLUSH
	HRRZ AC1,PRGNUM(J)	; TTY NUMBER
	HRLI AC1,UNHOLD
	CONO PI,PIOFF
	IDPB AC1,CLKQ
	CONO PI,PION
LFLUSH:	PUSH P,DDB		;SAVE AN AC
	MOVEI DDB,LEB(J)	;TURN OFF EDITOR BUFFER BY
	HRLI DDB,DISJMP		;PUTTING A RETURN JUMP
	MOVSM DDB,LEPPV(J)	;ON TOP OF THE POSITION VECTOR.
;	PUSHJ P,INIT1		;COMMENTED OUT BY FW SO CTRL-CR WILL WORK
	POP P,DDB
	HRRZS J,LETAB(DAT)	;RESET STATUS
	POPJ P,
;LEC1 LECB

LEC1:	JUMPE UCHN,LECB		;HERE FOR CTRL1-LETTER OR RUBOUT
	MOVE AC1,XDEL		;GET X DIMENSION OF A CHR.
	TLZE J,INSBT		;LEAVE INSERT MODE, IF WE ARE IN IT.
	PUSHJ P,INSP1		;READJUST CURSOR POSITION.
LECB:	SKIPN AC1,NUMARG(J)	;DID GUY TYPE RPT ARG ?
	AOS AC1,NUMARG(J)	;NO. USE 1.
	CAIN CHR,177
	JRST LEBS		;BACKSPACE.
	CAIN CHR," "
	JRST LECSP		;CTRL1 SPACE.
	CAIN CHR,14
	JRST LECFF		;CTRL1 FF
	TLNE J,EOLBT		;AT END OF LINE?
	JRST LE2		; YES, USER GETS TO SEE CTRL LETTERS.
	TRZ DSER,40		;CHANGE LOWER CASE LETTERS TO UPPER.
	CAIN DSER,"D"		;COMPARE UNSHIFTED CHAR.
	JRST LECD		;CTRL1-D
	CAIN DSER,"I"
	JRST LECI		;CTRL1-I
	CAIN CHR,11
	JRST LECT		;CTRL1-TAB
	CAIN DSER,"R"
	JRST RESRCH		;CTRL1 R - REPEAT PREVIOUS CTRL-S OR CTRL-K
	CAIN DSER,"K"
	TLOA J,KILLBT		;CTRL1-K
	CAIN DSER,"S"
	TLOA J,SRCHBT		;CTRL1-S
	JRST LE2		;RANDOM CTRL LETTER.
	JRST LECX1		;STORE NEW BITS IN J AND EXIT.

;LE2 LE2CR LE2X LE2XA LE2XB

LE2CR:	PUSHJ P,LECT		;SIMULATE A CTRL TAB (GO TO END OF LINE).
	MOVEI CHR,15		; RESTORE THE CR THAT MAKECR CLOBBERS

;;Here if CHR is not line editor command
LE2:	TLNN J,EOLBT		;AT END OF LINE ?
	JRST LE2A		;NO.
	TLNE J,NOCRBT		;ARE WE RE-EDITING THIS LINE ?
	CAIE CHR,15		;YES. DON'T PUT ANOTHER CR AT ITS END.
	SKIPA
	JRST ACTIV1		;JUST ACTIVATE GUY WHEN HE TYPES CR AT A RE-EDITED LINE.
	PUSHJ P,PUTCHR		;PLACE CHAR. IN BUFFER.
	MOVEM TAC,FCPOS(J)	;UPDATE FINAL CHAR. POS. CTR.
	JUMPG UCHN,ACTIV1	;ACTIVATE ON ANY CTRL BITS AT EOL.
	TLZ J,DMHARD		;This case is always easy, even if char is a tab

LE2X:	MOVE TAC,SPCTAB(CHR)	;SPECIAL BITS.
	TLNN TAC,BREAKB!FCSBRK	;A BREAK CHAR. ?
	TLNE IOS,DDTM		;IS EVERY CHAR. AN ACTIVATOR ?
	JRST ACTIV1		;YES.
	TLZE J,ACTNOW		; ARE WE OUT OF BUFFER SPACE?
	JRST ACTIV1		; YES, ACTIVATE NOW
	TLNE DAT,SPCBRK		;ARE WE IN SPECIAL ACTIVATION MODE?
	TLNE IOS,TPMON
	JRST LE2XA		;NO
	PUSHJ P,SPCACT		;TEST FOR BREAK.
	CAIA
LE2XA:	TRNE UCHN,CBIT1		;YES. ANY CTRL BITS ?
	JRST ACTIV1		;YES.
IFN FTINCL,<
	CAIN CHR,11
	JRST LECX		;We have already inserted spaces for this tab
	TLNE DAT,DMLIN
	TLNE DAT,DMDAMN		;Need to redraw whole editor?
	JRST LECX		;Not DM or redrawing whole thing
	TLNE J,DMHARD
	JRST LE2XB		;Must insert char
	PUSHJ P,PUTDMC		;Easy--just put out character
	JRST LECX		;Done

LE2XB:	PUSH P,CHR
	MOVEI CHR,ID		;ID mode on
	PUSHJ P,QUODMC
	MOVEI CHR,IDADDC	;Add a space
	PUSHJ P,QUODMC
	MOVEI CHR,CANCEL	;ID mode off
	PUSHJ P,QUODMC
	POP P,CHR
	PUSHJ P,PUTDMC		;Type character over space
>;FTINCL
	JRST LECX
;LE2A LEOVS LEOVD LEINS LEINS1 LEOVSC

;Here with character typed not at end of line
LE2A:	TRNN UCHN,CBIT2		;INSERT CHAR. IF CTRL 2. OR CTRL-I (OR BOTH)
	TLNE J,INSBT		;ARE WE IN INSERT MODE ?
	JRST LEINS		;YES.
	CAIN CHR,15
	JRST LE2CR		;CR'S GO AT END OF LINE.
	TRNE UCHN,CBIT1		;NOW TEST CTRL BIT 1
	JRST LEINS		;INSERT
	PUSH P,CHR		;WE'RE OVER-STRIKING. SAVE CHAR.
	MOVEI AC1,1		;FAKE A RPT. ARG. OF 1.
	MOVE TAC,LEPNT1(J)	;IF WE ARE ABOUT TO OVERSTRIKE
	CAIE CHR,11
	TLO J,DMHARD		;Use this as flag to LECD to not put out DM char
LEOVS:	ILDB AC2,TAC		;A TAB, AND IF THE TAB IS MORE
	JUMPE AC2,.-1
	CAIE AC2,11		; IS THIS A TAB?
	JRST LEOVD		; NO, JUST GO AHEAD AND OVERSTRIKE.
	ILDB AC3,TAC		;WE WILL INSERT INSTEAD.
	JUMPE AC3,.-1		; NO NULLS, PLEASE.
	CAIE AC3," "		; IS THIS REALLY A TAB OR A LONG LINE CRLF?
	JRST LEOVSC		; IS LONG LINE CRLF, READ PAST IT
	ILDB AC3,TAC		; PICK UP CHARACTER PAST SPACE
	JUMPE AC3,.-1
	CAIN CHR,11		;ALWAYS OVERTYPE IF NEW CHAR IS TAB
	TLCA J,CRBIT!DMHARD	;Flag INSTAB not to output spaces to DM, LECD not to delete char
	CAIN AC3,11		;YES. MORE THAN ONE SPACE ?
LEOVD:	PUSHJ P,LECD		;DELETE NEXT CHR. IN LINE.
	POP P,CHR		;NOW INSERT NEW ONE.
	TLZA J,DMHARD		;Overstriking is easy
LEINS:	TLO J,DMHARD		;But insertion is harder
	TLO J,NOBRBT		; FORCE REPOSITIONING OF THE LONG LINE CRLF
	CAIE UCHN,CBIT2		;INSERT VIA META?
	JRST LEINS1		;NO.
	MOVE AC1,XDEL		;GET X DIMENSION OF A CHR. (ARG TO INSP1)
	TLZE J,INSBT		;IF WE'RE IN INSERT MODE, WE LEAVE IT, ADJUSTING
	PUSHJ P,INSP1		;  THE III CURSOR POSITION.
	MOVEI UCHN,		; DON'T LET IT ACTIVATE IN SPECIAL ACT MODE
	PUSHJ P,SPCACT		; UNLESS IT WOULD'VE WITHOUT META
	MOVEI UCHN,CBIT2
LEINS1:	PUSHJ P,PUTCHR		;PLACE NEW CHR. IN LINE.
	AOS FCPOS(J)		;INC. TOTAL CHR. COUNT.
	MOVNI AC3,1(AC3)	;- NO. OF COLUMNS INSERTED.
	MOVE TAC1,LEPNT1(J)	;GET CURRENT POINTER.
	PUSHJ P,ADJTB		;GO FIDDLE NEXT TAB IN LINE.
	JFCL
	TLZ J,CRBIT		;This may have been set for INSTAB's benefit on DM
	JRST LE2X

LEOVSC:	ILDB AC3,TAC		; PICK UP NEXT CHARACTER
	CAIE AC3,11		; IS IT THE FINAL TAB YET?
	JRST LEOVSC		; NO, LOOK SOME MORE
	JRST LEOVS		; YES, NOW LOOK AGAIN.
;PUTLF PUTCHR PUTCH1 PUTCH2 PUTCH3

;;SUBROUTINES FOR INSERTING CHARACTERS IN THE LINE.

PUTLF:	MOVEI CHR,12		;INVENT A LINE FEED.
	AOS FCPOS(J)
PUTCHR:	SETZB AC3,NUMARG(J)	;CLEAR REPEAT ARG.
	PUSHJ P,INSCHR		;PLACE CHAR. INTO LINE.
	CAIN CHR,11		;DID WE INSERT A TAB ?
	PUSHJ P,INSTAB		;YES.
	MOVE AC2,XDEL		;PREPARE TO MOVE CURSOR.
	ADDM AC2,LEPPV(J)	;MOVE CURSOR OVER ONE PLACE.
	AOS DSER,LEHPOS(J)
	CAILE DSER,=72		;ARE WE AT RIGHT SIDE OF SCREEN ?
	PUSHJ P,SHIFTL		;YES. SHIFT THE LINE LEFT SOME.
	AOS TAC,CCPOS(J)	;CURRENT POSITION IN CHARS.
	CAIN CHR,15		;IS IT A CR ?
	JRST PUTLF		;YES.
	SKIPE III(J)		; IS THIS A DD OR DM DISPLAY?
	POPJ P,			; NO, LEAVE NOW
	PUSH P,AC3		; SAVE NUMBER OF CHARACTERS INSERTED
	MOVE AC3,CURPP(J)
	MOVE AC1,PPHPOS(J)	;GET INITIAL X POSITION
	ADD AC1,LEHPOS(J)	; ADD IN LINE EDITOR'S HORIZONTAL POSITION
	CAIE CHR,11		; WAS THE CHARACTER A TAB?
	JRST PUTCH1		; NO, BREAK ONLY IF EVENLY AT END OF LINE
	TLNN DAT,DMLIN		; DM's line is exact multiple of tab size
	ADDI AC1,4		; CENTER TAB ON END OF SCREEN FOR DD
	IDIV AC1,LNLNGT(AC3)	; SEE IF WE ARE NEAR THE END OF THE LINE
	CAIG AC2,10		; WITHIN + OR - 4 CHARACTERS?
PUTCH2:	TLO J,NOBRBT		; YES, DO LINE BREAKING CALCULATION THIS TIME
PUTCH3:	POP P,AC3		; RESTORE NUMBER OF CHARACTERS INSERTED
	POPJ P,

PUTCH1:	SUBI AC1,1
	IDIV AC1,LNLNGT(AC3)	; SEE IF WE ARE EXACTLY AT THE END OF THE LINE
	JUMPE AC2,PUTCH2	; YES, BREAK OUR LINE THIS TIME
	JRST PUTCH3		; RESTORE ACCUMULATOR AND LEAVE
;INSTAB INST1 INSCHR INSCH1 LEINSW INSW1 INST2 INST3 INST4

INSTAB:	MOVEI CHR," "		;A TAB. PREPARE TO (SIGH) SIMULATE IT.
	MOVE AC1,LEHPOS(J)	;GET LINE EDITOR HPOS
	SKIPN III(J)
	ADD AC1,PPHPOS(J)	;MAKE IT ABSOLUTE ON DD--WHY? BECAUSE OF WRAPAROUND?
	ANDCAI AC1,7		;HOW MANY SPACES TO INSERT (LESS 1).
	ADDM AC1,LEHPOS(J)
	PUSH P,AC1		;REMEMBER THE MAGIC NUMBER
	SKIPA AC2,XDEL		;PREPARE TO MOVE CURSOR.
INST1:	ADDM AC2,LEPPV(J)	;MOVE CURSOR OVER ONE PLACE.
	PUSHJ P,INSCHR		;INSERT A SPACE IN THE LINE.
	SOJGE AC1,INST1		;BACK FOR MORE IF APPROPRIATE .
IFN FTINCL,<
	TLNN DAT,DMLIN
	JRST INST2
	TLNE J,CRBIT		;Are we typing a tab over a tab?
	JRST INST4		;Yes, don't need to output spaces here on DM
	TLO J,DMHARD		;This case is sometimes hard since we insert spaces
	PUSH P,(P)		;Copy number of spaces being inserted minus one
	MOVEI CHR,ID
	PUSHJ P,QUODMC		;Enter ID mode
	MOVEI CHR,IDADDC
INST3:	PUSHJ P,QUODMC		;Insert a space
	SOSL (P)
	JRST INST3		;More
	MOVEI CHR,CANCEL
	PUSHJ P,QUODMC		;Leave ID mode
	SUB P,[1,,1]
INST4:	MOVEI CHR,LEMOVE
	PUSHJ P,QU2DMC		;Tell ttyser we want LE cursor moved
	MOVE CHR,(P)		;Number of spaces inserted minus one
	ADDI CHR,1		; plus one makes amount need to move cursor
	PUSHJ P,PUTDMC		;Put out low-order byte of cursor movement distance
	SETZ CHR,		;High-order byte is zero
	PUSHJ P,PUTDMC
>;FTINCL
INST2:	POP P,AC3		;Get back number of spaces inserted minus one
	MOVEI CHR,11		;NOW FINISH OFF WITH ANOTHER TAB.
INSCHR:	ILDB TAC,LEPNT1(J)	;LOOK AT NEXT CHR.
	JUMPE TAC,INSCH1	;IF NULL, PUT NEW CHR. ON TOP OF IT.
	MOVE TAC,LEPNT1(J)	;GET PTR.
	PUSHJ P,LEINSW		;INSERT A WORD OF NULLS.
INSCH1:	DPB CHR,LEPNT1(J)	;PUT NEW CHR. IN LINE.
	POPJ P,

LEINSW:	AOS DSER,LELWD(J)	;UPDATE PTR. TO RETURN JMP.
	CAMLE DSER,MAXPT(J)	;MORE ROOM IN BUFFER ?
	PUSHJ P,GCOLL		; BUFFER NEARLY FULL, COMPRESS OUT ALL THE NULLS
INSW1:	MOVE TAC1,(DSER)	;GET WORD FROM BUFFER AND
	MOVEM TAC1,1(DSER)	;MOVE IT UP ONE.
	CAILE DSER,(TAC)	;ARE WE DOWN TO WHERE WE WILL INSERT THE NULLS ?
	SOJA DSER,INSW1		;NO.
	MOVEI DSER,0		;PREPEARE TO INSERT NULLS.
	MOVE TAC1,TAC
	IDPB DSER,TAC1		;NULL NEXT CHAR. AFTER CURRENT ONE..
	IDPB DSER,TAC1		;..AND ALSO NEXT 3 AFTER THAT.
	IDPB DSER,TAC1
	IDPB DSER,TAC1
	TLZ J,TABB		;WE NO LONGER KNOW WHERE NEXT TAB IS.
	POPJ P,
;GCOLL GCOLL1 GCOLL2 GCOLL3 GCOLL4 PCHK 

; THIS IS THE LINE EDITOR'S GARBAGE COLLECTOR. IT GOES THROUGH THE
; BUFFER AND COMPRESSES OUT ALL THE NULL CHARACTERS. IT MUST RESET THE
; POINTER TO THE LAST WORD IN THE TABLE, LELWD, MUST RESET THE BYTE POINTERS
; IN LEPNT1 AND IN TAC.

GCOLL:	PUSH P,AC1		; FIRST, SAVE A FEW ACCUMULATORS
	PUSH P,AC2
	PUSH P,AC3
	PUSH P,UUO
	MOVSI AC1,440700	; NOW MAKE UP TWO BYTE POINTERS TO THE BUFFER
	MOVSI AC2,440700
	HRRI AC1,LEBUF(J)
	HRRI AC2,LEBUF(J)
	SETZ AC3,		; THIS WILL BE THE COUNT OF THE NULLS WE SQUEEZED OUT
GCOLL1:	MOVE UUO,AC1		; NOW, TEST FOR END OF BUFFER
	IBP UUO			; SEE WHAT ADDRESS WE WOULD HAVE ENDED UP ON
	HRRZS UUO		; CLEAN IT UP
	CAML UUO,LELWD(J)	; COMPARE TO END OF BUFFER
	JRST GCOLL4
	ILDB UUO,AC1		; PICK UP FIRST CHARACTER IN LINE
	JUMPN UUO,GCOLL2	; IF NOT A NULL, JUST STUFF IT IN THE BUFFER
	ADDI AC3,1		; ANOTHER NULL, COUNT IT
GCOLL3:	PUSHJ P,PCHK		; UPDATE BYTE POINTERS IF NECESSARY
	JRST GCOLL1		; GO BACK FOR MORE

PCHK:	CAMN AC1,LEPNT1(J)	; ARE WE TO THE MAIN POINTER YET?
	MOVEM AC2,LEPNT1(J)	; YES, UPDATE IT
	CAMN AC1,TAC		; HAVE WE GOTTEN TO THE POINTER IN TAC YET?
	MOVEM AC2,TAC		; YES, UPDATE IT TOO
	POPJ P,

GCOLL2:	IDPB UUO,AC2		; PUT THE CHARACTER DOWN IN ITS NEW POSITION
	JRST GCOLL3		; GO BACK FOR MORE

GCOLL4:	PUSHJ P,PCHK		; UPDATE FINAL POINTER
	CAIGE AC3,5		; DID WE COLLECT A FULL WORD OF NULLS?
	TLO J,ACTNOW		; NO, ACTIVATE JOB NOW
	HRRZI AC2,1(AC2)	; POINT FINAL POINTER TO LAST WORD IN BUFFER
	MOVE UUO,@LELWD(J)	; PICK UP RETURN JUMP
	MOVEM UUO,(AC2)		; PUT IT DOWN IN ITS NEW PLACE
	MOVEM AC2,LELWD(J)	; AND THIS IS THE NEW END OF BUFFER POINTER
	POP P,UUO		; RESTORE OUR ACCUMULATORS
	POP P,AC3
	POP P,AC2
	POP P,AC1
	POPJ P,
;LECT LECSP CKNFOR LECX LECX1 MVX1 MVX1A SHIFT2 CKNFO2

;;ROUTINES TO PERFORM EDITING FUNCTIONS.

LECT:	MOVEI AC1,=200		;A CTRL TAB. SIMULATE 200 CTRL SPACES.
LECSP:	JSP TAC,CKNFOR		;CTRL SPACE. PREPARE TO MOVE CURSOR FORWARD.
	PUSHJ P,MOVEIT		;MOVE IT.
	MVFOR			;MOVE FORWARD, PLEASE.
	TLO J,NOTEXT		; NOTE THAT WE HAVE ONLY CHANGED THE CURSOR POSITION, NOT THE TEXT
MVX1:	MOVEM TAC1,LEPNT1(J)	;UPDATE THE BYTE POINTER.
MVX1A:
IFN FTINCL,<
	TLNN DAT,DMLIN
	JRST MVX1B		;Not Datamedia
	PUSH P,AC2		;Save amount of movement
	PUSH P,CHR		;Remember whether we did any deleting
	MOVEI CHR,LEMOVE
	PUSHJ P,QU2DMC		;Put out quoted LEMOVE char, leaving room for 2 more
	LDB CHR,[POINT 7,-1(P),35] ;Get low-order bits of movement amount
	PUSHJ P,PUTDMC
	LDB CHR,[POINT 7,-1(P),28] ;Get high-order bits
	PUSHJ P,PUTDMC
	POP P,CHR
	JUMPN CHR,MVX1C		;Jump if just cursor movement needed
	MOVM AC2,(P)		;Number of columns to delete
	PUSHJ P,DMDELE		;Tell DM to delete some chars
MVX1C:	POP P,AC2
MVX1B:
>;FTINCL
	MOVE DSER,AC2
	IMUL AC2,XDEL2		;CALC. AMOUNT TO MOVE CURSOR.
	LSH AC2,1		;THIS IS TO HANDLE OVERFLOW.
SHIFT2:	ADDM AC2,LEPPV(J)	;UPDATE THE POSITION VECTOR.
	ADDB DSER,LEHPOS(J)	;UPDATE HORIZONTAL POS. CNT.
	CAIG DSER,=72		;PAST RIGHT HAND MARGIN ?
	JUMPGE DSER,.+2		;OR MAYBE PAST LEFT ?
	PUSHJ P,SHIFT
LECX:	TLZ J,SRCHBT!KILLBT	;MUST CLEAR KILLBT- NEEDED FOR CTRL-K
	SETZM NUMARG(J)
LECX1:	MOVE AC3,PPHPOS(J)
	EXCH AC3,LSTHP(J)	; SEE THAT AS OUR NEW HORIZONTAL STARTING POSITION
	CAMN AC3,LSTHP(J)	; IS IT THE SAME AS LAST TIME
	TLZE J,NOBRBT		; OR HAS THIS LINE BEEN UNTOUCHED
	PUSHJ P,MAKECR		; VIRGIN LINE OR DIFFERENT HORIZONTAL POSITION
	TLZE J,ACTNOW		; DO WE HAVE TO ACTIVATE NOW?
	JRST ACTIV1		; YES, DO SO
	HLLM J,LETAB(DAT)	;UPDATE THE STATUS BITS.
	POPJ P,

CKNFOR:	TLOE J,EOLBT		;AT END OF LINE ALREADY ?
	JRST LECX		;YES. CAN'T MOVE FORWARD.
CKNFO2:	ADD AC1,CCPOS(J)	;FIND POS. AFTER MOVE.
	CAMGE AC1,FCPOS(J)	;WILL MOVE TAKE US TO END OF LINE ?
	TLZA J,EOLBT		;NO. RESET FLAG SAYING WE ARE THERE.
	MOVE AC1,FCPOS(J)	;YES. DON'T LET IT TAKE US PAST END.
	EXCH AC1,CCPOS(J)	;PUT BACK NEW POSITION.
	SUB AC1,CCPOS(J)	;GET -NO. OF PLACES TO MOVE.
	JRST (TAC)		;RETURN.
;LECFF LEBS BSP1 BSP2 BSP3

LECFF:	MOVEI AC1,=200		;SIMULATE 200 CTRL BS'S
	MOVEM AC1,NUMARG(J)
LEBS:	CAIN UCHN,CBIT2!CBIT1
	JRST LE2		;LET USER SEE CTRL-META BS
	SKIPN CCPOS(J)		;BACKSPACE OR CTRL BACKSPACE.
	JRST LECX		;IGNORE BS AT START OF LINE.
	TRZE UCHN,CBIT2
	JRST .+3		;META-BS ALWAYS DELETES
	TLNN J,EOLBT!INSBT	;ARE WE AT END OF LINE OR IN INSERT MODE ?
	HRRI UCHN,10		;NO. FORCE NON-DELETING BS. (UCHN > 0)
	MOVN AC1,NUMARG(J)	;- RPT. ARG.
	ADDM AC1,CCPOS(J)	;POSITION AFTER MOVE.
	SKIPL AC2,CCPOS(J)	;WILL MOVE GO PAST START OF LINE 
	JRST BSP1		;NO.
	SUB AC1,AC2		;YES. RE-ADJUST CNT. SO IT WON'T.
	SETZM CCPOS(J)		;MARK AT BEGINNING OF LINE.
BSP1:	JUMPG UCHN,BSP3		;CTRL BITS ?
BSP2:	ADDM AC1,FCPOS(J)	;NO. WE WILL ACTUALLY DELETE CHRS.
	TLZ J,NOCRBT		;THIS IS FOR BENEFIT OF INIT4.
	TDZA CHR,CHR		;SET CHR TO 0 SO MOVEIT WILL DELETE.
BSP3:	TLZ J,EOLBT		;CTRL BACKSPACE. NO LONGER ARE WE AT END OF LINE.
	PUSHJ P,MOVEIT
	MVBAK			;MOVE BACKWARD RIGHT AMOUNT.
	MOVNS DSER,AC2		;- NO. OF COLUMNS MOVED.
	TLO J,NOTEXT		; MARK CURSOR CHANGE ONLY
	JUMPG UCHN,MVX1		;IF NON-DELETING BACKSPACE, JUST UPDATE CURSOR AND LEAVE.
	TLZ J,NOTEXT		; AHA, TEXT IS CHANGED TOO!
	MOVEM TAC1,LEPNT1(J)
	PUSH P,AC2		;SAVE -NUMBER OF COLUMNS MOVED.
	PUSHJ P,ADJTB
	JFCL			;IGNORE SKIP RETURN
	POP P,AC2		;GET BACK NUMBER OF COLUMNS MOVED.
	JRST MVX1A
;LECI INSP1 LECD SRCHCR DMDELE

LECI:	TLOE J,INSBT		;FLAG INSERT MODE.
	JRST LECX		;ALREADY IN THAT MODE !
	TLO J,NOTFR		; THIS IS A SILENT ONE
	PUSHJ P,LECX		;UPDATE STATUS WORD.
	MOVN AC1,XDEL
INSP1:	ASH AC1,-1		;FOR INSERT MODE, WE MOVE CURSOR BY
	ADDM AC1,LEPPV(J)	; 1/2 A CHAR. WIDTH.
	LDB AC2,[POINT 11,LEPPV(J),21]
				;NOW THE Y POS.
	ASH AC1,-=26		;(MOVE IT BY 1/4 CHAR. WIDTH.)
	SUB AC2,AC1		;(MOVE IT IN OTHER DIRECTION,TOO.)
	DPB AC2,[POINT 11,LEPPV(J),21]
	POPJ P,

SRCHCR:	TLNN TAC,KILLBT		;ARE WE KILLING OR JUST MOVING?
	JRST LECT		;JUST MOVE TO END OF LINE
	MOVEI AC1,=200		;KILL TO END OF LINE
LECD:	JSP TAC,CKNFOR		;CTRL D. PREPARE TO MOVE FORWARD.
	ADDM AC1,FCPOS(J)	;DECREMENT NO. OF CHRS. IN LINE.
	ADDM AC1,CCPOS(J)	;DON'T INCREMENT THE CURRENT POSITION.
	MOVEI CHR,0		;SET TO DELETE...
	PUSHJ P,MOVEIT		;MOVE FORWARD, DELETING.
	MVFOR
IFN FTINCL,<
	TLNE DAT,DMLIN
	TLNE J,DMHARD
	JRST ADJNTB		;Coming from LEOVD, don't diddle DM display yet
	PUSH P,AC3		;Save number of columns deleted for ADJNTB
	PUSHJ P,DMDELE		;Delete appropriate number of columns on DM
	POP P,AC3
>;FTINCL
	JRST ADJNTB		; ADJUST NEXT TAB  - CLEAR KILLBT FROM J

IFN FTINCL,<
DMDELE:	CAIG AC2,=79		;If need to delete more than whole line,
	SKIPE NCRS(J)		; or if line previously wrapped around,
	JRST DMDEL2		; then redraw whole line
	PUSH P,AC2		;Save count
	MOVEI CHR,LEDELE
	PUSHJ P,QU2DMC		;Put out quoted LEDELE char, leaving room for 2 more
	POP P,CHR
	JRST PUTDMC		;Put out count of deletions to make

DMDEL2:	TLO J,DMDAMN		;We may need to move text from beginning of line 2
	POPJ P,			; to end of line 1--force redrawing of whole line
>;FTINCL
;ADJNTB ADJTB LECD4A LECD6 LECD5 LECD5A

; THIS ROUTINE ADJUSTS THE NEXT TAB, AS GIVEN BY THE BYTE POINTER IN TAC.
; THE COUNT OF THE NUMBER OF COLUMNS THE LINE HAS BEEN MOVED BY IS IN AC3.

ADJNTB:	PUSHJ P,ADJTB		; ADJUST OUR TABS
	JRST LECX		; (CLEAR KILLBT FROM J)
	JRST LECX		; (CLEAR KILLBT FROM J)

ADJTB:	TLNN J,TABB+NOTABB	;DO WE KNOW ABOUT NEXT TAB ?
	PUSHJ P,FNTAB		;NO. FIND OUT.
	TLNN J,TABB		;IS THERE ONE ?
	POPJ P,			;NO.
	ANDI AC3,7		;COUNT MOD 8 OF CHRS. DELETED.
	JUMPE AC3,CPOPJ		;NO CHANGE IF MULTIPLE OF 8.
	TLNN J,CRBIT		;Did we just type a tab over a tab?
	TLO J,DMDAMN		;No, oh well, we'll figure this case out later
	MOVE AC2,NTABCT(J)	;GET SIZE OF NEXT TAB.
	ADD AC2,AC3		;NEW SIZE OF NEXT TAB.
	MOVE TAC,NTABPT(J)	;PTR. TO LAST SPACE IN NEXT TAB.
	CAIG AC2,10		;IS NEW SIZE TOO BIG ?
	JRST LECD5		;NO. TAB NEEDS TO GROW.
	SUBI AC2,10
	EXCH AC2,NTABCT(J)	;YES. TAB MUST SHRINK.
	SUB AC2,NTABCT(J)	;FIND OUT HOW MUCH TO SHRINK IT.
	MOVEI AC1,0
LECD4A:	DPB AC1,TAC		;NULL ONE OF THE SPACES IN THIS TAB.
	ADD TAC,[XWD 70000,0]	;DECREMENT POINTER.
	JUMPG TAC,.+2
	SUB TAC,[XWD 430000,1]
	SOJG AC2,LECD4A
LECD6:	MOVEM TAC,NTABPT(J)	;STORE UPDATED PTR.
	JRST CPOPJ1

LECD5:	MOVEI AC1," "		;PREPARE TO MAKE TAB GROW.
	MOVEM AC2,NTABCT(J)	;STORE NEW SIZE.
LECD5A:	ILDB TAC1,TAC
	JUMPE TAC1,.+2		;IS THERE A NULL NEXT ?
	PUSHJ P,LEINSW		;NO. PUT SOME IN.
	DPB AC1,TAC		;ADD A SPACE.
	SOJG AC3,LECD5A
	JRST LECD6
;SEARCH RESRCH SRCHL GETEM GETEM1 GETEM2 GETEM0

SEARCH:	MOVEI TAC,(CHR)		;SAVE CHR. TO BE SEARCHED FOR.
	HLL TAC,J		;COPY KILLBT FROM J
	MOVEM TAC,LESVCH(J)	;SAVE ARGUMENT FOR CTRL R
RESRCH:	MOVE TAC,LESVCH(J)	;GET ARG FROM CTRL R
	MOVEI CHR,(TAC)
	CAIN CHR,15
	JRST SRCHCR		;MOVE OR KILL TO END OF LINE
	MOVEI AC1,1		;INITIALIZE REPEAT COUNT FOR LATER
	MOVE AC3,LEPNT1(J)	;MAKE COPY OF CURRENT POINTER.
	MOVEI TAC1,AC3		;PARAMETER FOR GETEM.
	PUSHJ P,GETEM		;SKIP OVER CURRENT CHR. BEFORE STARTING SEARCH.
SRCHL:	PUSHJ P,GETEM		;GET NEXT CHR. FROM LINE.
	CAIN CHR,EOLCHR		;ARE WE AT END OF LINE ?
	JRST LECX		;YES. DO NOTHING, CHR. NOT FOUND.
	CAIN CHR,(TAC)		;HAVE WE FOUND IT ?
	SOSLE NUMARG(J)		;YES. IS THE REPEAT COUNT EXHAUSTED ?
	AOJA AC1,SRCHL		;NO. COUNT PLACES MOVED AND LOOK SOME MORE.
	TLNN TAC,KILLBT		;YES.  ARE WE KILLING OR JUST MOVING UP TO IT ?
	JRST LECSP		;MOVEING.
	JRST LECD		;KILLING.

GETEM:	ILDB CHR,(TAC1)		;GET A NON-NULL CHAR. FROM LINE.
GETEM0:	JUMPE CHR,.-1
	CAIN CHR,11		;IS IT A TAB ?
	TLCN J,XTABBT		;YUP. ALREADY INSIDE A TAB ?
	TLNN J,XTABBT		;INSIDE A TAB ?
	JRST GETEM1		; NO, EXIT
	CAIE CHR,11		; ARE WE INSIDE A CRLF?
	CAIN CHR," "
	JRST GETEM2		; NO. PASS OVER THE TAB.
	TLO J,CRBIT		; YES, MARK THIS AS A LONG LINE CRLF
	JRST GETEM		; LOOP BACK FOR NEXT CHARACTER

GETEM1:	TLZE J,CRBIT		; ARE WE COMING OUT OF A CRLF?
	JRST GETEM		; YES, GET NEXT CHARACTER PAST IT
	POPJ P,			; NO

GETEM2:	TLZ J,CRBIT
	JRST GETEM
;LEDESC ESCR ESCP ESCZ

LEDESC:	CAIN CHR,10044
	JRST CLEAR
	CAIN CHR,10041
	JRST ESCHX
	TLO J,NOTFR		; THIS IS A SILENT TRANSFER
	TRZ DSER,40		; CHANGE LOWER TO UPPER CASE
	CAIN DSER,"O"
	JRST ESCO
	CAIN DSER,"R"		; REFRESH HIS LINE EDITOR?
	JRST ESCR		; YES
	PUSHJ P,TTYESC
	JRST LECX1

ESCR:	SKIPN III(J)		; DON'T REFRESH IF ON A III
	TLZ J,NOTEXT!NOTFR	; QUEUE UP A COMBINED TEXT AND CURSOR TRANSFER
	TLO J,DMDAMN		;Force out whole DM LE
	JRST LECX1

ESCP:	JUMPL AC1,BRKP		;<BREAK>P DOES THE WORKS
	HRLI AC2,LERFP		; USE THE MAGIC CLOCK LEVEL ROUTINE FOR REFRESHING THE PAGE
	JRST ESCC1

;ESC Z MEANS BEEP WHEN JOB IS DONE AFTER LONG WAIT, BREAK Z MEANS DON'T
↑ESCZ:	LDB AC2,PJOBN		;GET JOB NUMBER OF THIS GUY
	JUMPE AC2,CPOPJ		;IF YOU'RE NOT LOGGED IN, I CAN'T HELP YOU
	ROT AC1,1		;PUT SIGN BIT INTO LOW-ORDER BIT
	TRC AC1,1		;MAKE SIGN BIT ON MEAN CLEAR SIGN BIT OF JBTMSC
	DPB AC1,[POINT 1,JBTMSC(AC2),0] ;SET OR CLEAR SIGN BIT OF JBTMSC AS FLAG
	POPJ P,
;TTYESC

;HERE ARE THE ESCAPES THAT CAN BE CALLED FROM TTYSET UUO, WHICH IN FACT ENTERS HERE
↑TTYESC:
;The first few escapes can be executed for any TTY, whether a display or not.
	CAIN DSER,"Z"
	JRST ESCZ		;SIGNAL USER WHEN JOB DONE AFTER CERTAIN TIME
	CAIN DSER,"F"
	JRST ESCF		;YES. GO SEE ABOUT FCS MODE.
	CAIN DSER,"I"
	JRST ESCI
	CAIN DSER,"X"
	JRST ESCX		;SET OR CLEAR UPDATE BIT IN XTIME FOR THIS JOB
	JUMPE J,CPOPJ		;JUMP IF FROM TTYSET AND NO DISPLAY
;The remaining escape commands require you to be on a display.
	CAIN DSER,"W"
	JRST ESCW
	CAIN DSER,"Q"
	JRST ESCQ		;GET WHO LINE FOR NEXT JOB WITH SAME PROG NAME
	CAIN DSER,"G"
	JRST ESCG
	CAIN DSER,"L"
	JRST ESCL
	CAIN DSER,"Y"
	JRST ESCY
	CAIN DSER,"N"
	JRST ESCN
	CAIN DSER,"E"
	JRST ESCE
	CAIN DSER,"J"
	JRST ESCJ
	CAIN DSER,"C"		; CLEAR SCREEN?
	JRST ESCC		; YES, GO QUEUE UP AN ERASE REQUEST
	CAIN DSER,"P"		; REFRESH HIS PAGE PRINTER?
	JRST ESCP		; YES, GO QUEUE UP A PAGE PRINTER REQUEST
	TLNE DAT,DDDLIN		; SKIP UNLESS DD
	CAIE DSER,"H"
	POPJ P,
	JRST ESCH		;HIDE (OR UNHIDE) HIS CHANNEL
;CLEAR LECLR LECLR2

CLEAR:	CAIN UCHN,CBIT1		; <CTRL>CLEAR?
	JRST ESCU		; YES, UNHOLD
	JUMPN UCHN,CPOPJ	; NO, JUST FLUSH LINE UNLESS IT'S GOT <META>
	;FALL THROUGH INTO REAL CLEAR CODE
; THIS ROUTINE CLEARS THE LINE EDITOR BUFFER WITHOUT DISTURBING
; ITS STATUS. THIS MEANS THAT THE INFORMATION AS TO WHETHER
; THIS IS A RE-EDITED LINE IS PRESERVED.
LECLR:	JUMPGE J,CPOPJ		;NOTHING TO CLEAR
	TLNE J,WTFLAG		;ESCAPES AVOID THIS TEST FOR WAIT FLAG
	JRST TPOPJ		; BUT WE BETTER NOT DO ANYTHING NOW
	MOVEI AC1,=200
	JSP TAC,CKNFO2		;PREPARE TO MOVE FORWARD 200 CHARS
	JUMPGE AC1,LECLR2
	PUSHJ P,MOVEIT		;GO
	MVFOR			;ARG TO MOVEIT
	MOVEM TAC1,LEPNT1(J)	;STORE NEW BYTE POINTER
LECLR2:	MOVEI CHR,15		;PUT CRLF ON END OF LINE
	PUSHJ P,INSCHR		; (DON'T YOU HATE TYPING CRLF AND NOT
	MOVEI CHR,12		; GETTING THE CRLF?)
	PUSHJ P,INSCHR
	MOVEI CHR,2
	ADDM CHR,FCPOS(J)	;COUNT THE CR AND LF
	TLZ J,¬REEDBT		;CLEAR ALL THE BITS BUT THAT INDICATING REEDITED LINE
	PUSH P,LEPNT1(J)
	PUSHJ P,INIT3		;RESET MOST STUFF
	POP P,LEPNT1(J)
	MOVEI DDB,LEB(J)
	HRLI DDB,DISJMP
	MOVSM DDB,LEPPV(J)	;DON'T DISPLAY THE BUFFER ON IIIS
	TLO J,DMDAMN
	POPJ P,			;NOW CTRL-CR WILL UNDO THE CLEAR, UNLESS SUPPRESSED
;ESCC ESCC0 ESCC1 ESCC2 BRKP ESCG ESCL ESCHX

; WE GET HERE IF THE LOSER TYPES <ESC>C OR <ESC>¬C WHICH CAUSES
; HIS SCREEN (IF HE IS A DATA DISC TYPE) TO GET ERASED TO BLACK OR
; WHITE RESPECTIVLY.

ESCC:	SKIPE III(J)
	JRST ESCC0
	HRRZ AC2,CURPP(J)	; PICK UP PAGE PRINTER CONTROL BLOCK ADDRESS
	MOVSI AC3,(1B5)		; PICK UP BLACK BIT
	JUMPL AC1,.+3
	ORM AC3,DDCW(AC2)
	JRST .+2
	ANDCAM AC3,DDCW(AC2)
ESCC0:	MOVSI AC2,LEERS		; USE CLOCK LEVEL ROUTINE IN DPYSER THAT QUEUES IT UP
ESCC1:	HRRI AC2,(J)		; PUT IN THE DPY PROGRAM HEADER ADDRESS
ESCC2:	CONO PI,PIOFF
	IDPB AC2,CLKQ
	CONO PI,PION
	POPJ P,

BRKP:	HRLI AC2,RFPCS		; <BREAK>P CLEARS THE SCREEN AND REFRESHES BOTH
	JRST ESCC1		;    THE PAGE PRINTER AND THE LINE EDITOR.

ESCG:	HRLI AC2,PPGSET		; ROUTINE TO SET PAGE PRINTER GLITCHES/PAGE
	JRST ESCY1

ESCL:	HRLI AC2,PPLSET		; LINES/GLITCH
	JRST ESCY1

ESCHX:	SETOM DPHOLD(J)		; PUT PAGE PRINTER IN HOLD
	TLNN DAT,DMLIN
	JRST LECX1
	MOVE AC2,DAT		;Line number for DPYTYP
	HRLI AC2,DPYTYP
	HRRZ AC1,DMPPPT(J)	;If anything in PP queue,
	CAIE AC1,DMPPPT-QLINK(J); then plant clock request for DPYTYP
	PUSHJ P,ESCC2		; to force out stars (thru LE queue).
	JRST LECX1
;ESCJ ESCE ESCU ESCY ESCY1 ESCN

ESCJ:	DPB AC1,[POINT 9,GWORD(J),26]	; SET NUMBER OF GLITCHES BEFORE HOLD
	MOVEM AC1,GLHCNT(J)
	TRNN AC1,-1
	SETOM GLHCNT(J)
	POPJ P,

ESCE:	DPB AC1,[POINT 9,GWORD(J),17]	; SET NUMBER OF LINES BEFORE HOLD
	MOVEM AC1,LHCNT(J)
	TRNN AC1,-1
	SETOM LHCNT(J)
	POPJ P,

ESCU:	SETZ AC1,		; ROUTINE TO UNHOLD THE PAGE PRINTER
	EXCH AC1,DPHOLD(J)
	JUMPE AC1,LECX1
	HRRZ AC2,PRGNUM(J)
	HRLI AC2,UNHOLD
	PUSHJ P,ESCC2
	JRST LECX1

ESCY:	HRLI AC2,PPYSET		; ROUTINE TO SET Y-POSITION
ESCY1:	HRRZM AC1,LEARG(J)
	JRST ESCC1

ESCN:	MOVE DSER,AC1		; NORMALIZE PAGE PRINTER
	PUSHJ P,VDESCN		;NORMALIZE VDS ON DD (NO-OP IF NOT DD)
	MOVSI AC2,LEERSN
	JUMPL DSER,ESCC1
	MOVSI AC2,PPNSET
	JRST ESCC1
;ESCH UNHIDE ESCO ESCF

ESCH:	MOVSI AC3,400000	;SET OR CLEAR CONSOLE PRIVACY BIT
	HLR AC1,PRGNUM(J)
	JUMPL AC1,UNHIDE	;BREAK-H MEANS UNHIDE
	TDNE AC3,DDTAB(AC1)
	POPJ P,
	IORM AC3,DDTAB(AC1)
	PUSHJ P,DDFLSH
	POPJ P,

UNHIDE:	ANDCAM AC3,DDTAB(AC1)
	POPJ P,

ESCO:	MOVEI IOS,IOSUPR	;ASSUME AN UN-↑O.
	ANDCAB IOS,DEVIOS(DDB)
	JUMPL AC1,LECX1
	PUSHJ P,LECX1		;GET STATUS BITS STORED AND RESET.
	PUSH P,J		; SAVE THE DPY PROGRAM HEADER
	PUSHJ P,CONTOB		; DO A ↑O.
	PUSHJ P,UTYPET		;AND MAKE SURE IT GETS OUT
	POP P,J
	POPJ P,

ESCF:	JUMPL AC1,.+2
	TLOA DAT,FCS		;TURN ON THE ↑F BIT (FULL CHR. SET).
	TLZ DAT,FCS		;WRONG. TURN IT OFF.
	HLLM DAT,LINTAB(DAT)
	POPJ P,
;ESCW ESCW2 ESCW1 ESCQ ESCQY ESCQX

ESCW:	JUMPGE	AC1,ESCW1	;TURN ON WHO LINE?
	SETZM	WHOTAB(J)	;TURN OFF WHO LINE
	POPJ	P,

ESCW2:	TLZ	AC1,-1		;THIS IS WHERE [ESC] # Q DOES [ESC] # W
ESCW1:	TRNN	AC1,-1
	LDB	AC1,PJOBN	;GET JOB NUMBER OUT OF DDB IF NO ARGUMENT.
	CAIL	AC1,JOBN	;LEGAL JOB?
	POPJ	P,		;NO
				;PUT INTO WHO TIME TABLE
	MOVE	AC2,JBTSTS(AC1)	;GET JOB STATUS WORD.
	TLNE	AC2,JNA		;IS IT LOGGED IN?
	HRROM	AC1,WHOTAB(J)	;YES, STORE JOB #.  ALSO PUT -1 IN INCR TIME SLOT.
	SETZM	WHORUN(J)	;CLEAR TIME TO UPDATE RUNTIME NEXT
	POPJ	P,		;THAT'S ALL.

ESCQ:	TRNE	AC1,-1		;ANY ARGUMENT?
	JRST	ESCW2		;[ESC] # Q AND [BRK] # Q ARE SAME AS [ESC] # W
	MOVEI	AC3,1		;ASSUME POSITIVE INCREMENT FOR GOING THRU TABLE
	JUMPGE	AC1,.+2		; UNLESS HE SAID [BRK] Q
	MOVNI	AC3,1		; IN WHICH CASE WE USE NEGATIVE INCREMENT
	SKIPN	AC1,WHOTAB(J)	;GET NUMBER OF JOB ON WHO LINE
	LDB	AC1,PJOBN	;NO WHO LINE.  USE USER'S JOB.
	ANDI	AC1,-1		;MAKE SURE TAC HAS ONLY THE JOB NUMBER
	JUMPE	AC1,CPOPJ	;IF NOT LOGGED IN AND NO WHO LINE UP, FORGET IT
	HRRZ	AC2,PRJPRG(AC1)	;GET PROGRAMMER NAME OF OLD WHO LINE JOB
	PUSHJ	P,ESCQY
	POPJ	P,		;NOTHING FOUND
	HRROM	AC1,WHOTAB(J)	;YES!  SAVE JOB NUMBER.  -1 INTO INCR TIME.
	SETZM	WHORUN(J)	; AND CLEAR TIME TO UPDATE RUNTIME NEXT
	POPJ	P,

;CALLED FROM VDESCM CODE IN TTYSER.  
;AC2←PRG NAME. AC3←DIRECTION (1 OR -1). AC1←STARTING JOB NUMBER.
;SKIP RETURN IF SUCCESS.

↑ESCQY:	PUSH	P,TAC		;PRESERVE TAC
	PUSHJ	P,ESCQX		;LOOK FROM AC1 TO END OF TABLE
	JRST	TPOPJ1		;GOT ONE
	XORI	AC1,JOBN	;START OVER AT OTHER END OF TABLE
	PUSHJ	P,ESCQX		; AND LOOK THROUGH WHOLE TABLE
	JRST	TPOPJ1		;GOT ONE.
	JRST	TPOPJ		;NO JOB FOUND WITH SAME PN, NOT EVEN ORIGINAL JOB.

ESCQX:	ADD	AC1,AC3		;MOVE ON TO NEXT JOB
	CAIGE	AC1,JOBN	;AT END OF TABLE YET?
	JUMPG	AC1,.+2		; OR AT BEGINNING OF TABLE?
	JRST	CPOPJ1		;YES TO ONE OF THESE
	HRRZ	TAC,PRJPRG(AC1)	;GET PROGRAMMER NAME FOR THIS JOB
	CAIE	TAC,(AC2)	;IS IT THE ONE WE ARE LOOKING FOR?
	JRST	ESCQX		;NO
	MOVE	TAC,JBTSTS(AC1)
	TLNN	TAC,JNA
	JRST	ESCQX
	POPJ	P,		;DIRECT RETURN FOR SUCCESS
;ESCI ESCX ESCX1

ESCI:	MOVSI AC1,INTTTI	;<ESC>I INTERRUPTS ON THE INTTTI BIT IN LEFT HALF
	LDB AC2,PJOBN
	TDNN AC1,JBTIEN(AC2)
	POPJ P,
	ORM AC1,JBTIRQ(AC2)
	SETOM INTREQ(PID)
	POPJ P,

ESCX:	LDB	AC2,PJOBN	;GET JOB NUMBER OF THIS GUY
	JUMPE	AC2,CPOPJ	;IF YOU'RE NOT LOGGED IN, I CAN'T HELP YOU
	MOVSI	TAC,400000	;THIS IS THE BIT WE WILL SET OR CLEAR
	JUMPN	AC1,.+3		;WAS IT PLAIN [ESC]X?
	ANDCAM	TAC,XTIME(AC2)	;YES.  TURN OFF THE NO-UPDATE BIT IN XTIME
	POPJ	P,		;BYE
	TRNE	AC1,-1		;WAS THERE AN ARGUMENT TO ESCAPE COMMAND?
	JRST	.+3		;YES
	ORM	TAC,XTIME(AC2)	;NO.  MUST HAVE BEEN [BRK]X.  TURN ON NO-UPDATE FLAG
	POPJ	P,
	SETZ	AC3,
	HRRZS	DSKOPS(AC2)	;MAKE ALL DISK OPS "RECENT"
	JUMPL	AC1,ESCX1	;WAS IT [ESC] OR [BRK]?
	SKIPGE	AC3,JBTWAT(AC2)	;[ESC]1 X.  UPDATE JB2WAT
	ADD	AC3,UPTIME	;MAKE WAIT TIME HONEST
	HRLS	DSKOPS(AC2)	;ZERO INCREMENTAL COUNT OF DISK OPERATIONS
	ADD	TAC,TTIME(AC2)	;[ESC]1 X.  UPDATE XTIME AND SET NO-UPDATE BIT
ESCX1:	MOVEM	TAC,XTIME(AC2)	;[BRK]1 X MEANS CLEAR XTIME AND SET NO-UPDATE BIT
	MOVEM	AC3,JB2WAT(AC2)	;SAVE NEW VALUE OF OLD WAIT TIME
	POPJ	P,
;FNTAB FNT1 FNT2 FNT3 FNT4 FNT5

FNTAB:	TLO J,NOTABB		;PREPARE TO FIND NEXT TAB IN LINE.
FNT1:	ILDB TAC,TAC1		;LOOK AT NEXT CHR.
	CAIN TAC,EOLCHR		;ARE WE AT END OF LINE ?
	POPJ P,			;YUP. RETURN LEAVING `NO TAB' BIT SET.
	CAIE TAC,11		;A TAB ?
	JRST FNT1		;NO.
	MOVE AC2,TAC1		; SEE IF THIS TAB IS REALLY A LONG LINE CRLF
	ILDB AC2,AC2		; PICK UP CHARACTER PAST TAB
	CAIN AC2," "		; IS IT A SPACE?
	JRST FNT3		; YES, MUST BE REAL TAB
FNT4:	ILDB TAC,TAC1		; NO, MUST BE LONG LINE CRLF. READ PAST IT.
	CAIE TAC,11		; IS THIS A TAB?
	JRST FNT4		; NO, READ SOME MORE
	JRST FNT1		; YES, GET NEXT CHARACTER PAST CRLF

FNT3:	MOVEI AC2,0		;COUNT NO. OF SPACES IN TAB.
	TLC J,TABB!NOTABB	;SET BITS PROPERLY.
FNT2:	ILDB TAC,TAC1
	JUMPE TAC,.-1		; SKIP NULLS
	CAIE TAC," "		;ARE WE OUT OF SPACES YET ?
	JRST FNT5
	MOVEM TAC1,NTABPT(J)	;STORE PTR. TO LAST SPACE IN TAB.
	AOJA AC2,FNT2		;NO. KEEP COUNTING.

FNT5:	CAIE TAC,11		; IS THIS REALLY THE TERMINATING TAB?
	JRST FNT2		; NO, GO BACK FOR MORE
	MOVEM AC2,NTABCT(J)	;STORE SIZE OF TAB.
	POPJ P,
;MOVEIT MVFOR MVBAK MVA MVA1 MVA2

;;MOVEIT MOVES THE PTR. FORWARD OR BACKWARD BY THE NO. OF PLACES
;; IN AC1, AND DELETES CHARS. PASSED OVER IF CHR=0.

MOVEIT:	MOVE TAC1,LEPNT1(J)	;GET CURRENT POINTER.
	POP P,DSER		;GET PTR. TO ARGUMENT.
	SETZB AC2,AC3
	MOVEM AC1,1(P)		;REMEMBER COUNT.
	SKIPN CHR		; ARE WE DELETING?
	TLO J,NOBRBT		; YES, REDO THE LONG-LINE CRLF WHEN DONE
	TLZ J,XTABBT		; CLEAR TAB BIT
	JRST @(DSER)		;GO TO EITHER MVFOR OR MVBAK.

MVFOR:	ILDB TAC,TAC1		;LOOK AT NEXT CHR.
	JUMPE TAC,.-1		;IGNORE NULLS.
	JUMPN CHR,MVA		;DON'T DELETE UNLESS CHR =0.
	DPB CHR,TAC1		;DELETE IT.
	JRST MVA
	
MVBAK:	LDB TAC,TAC1		;LOOK AT CURENT CHR.
	JUMPN CHR,.+2		;DELETE IT IF APPROPRIATE,
	DPB CHR,TAC1
	ADD TAC1,[XWD 070000,0]	;DECREMENT POINTER.
	JUMPG TAC1,.+2
	SUB TAC1,[XWD 430000,1]
	JUMPE TAC,MVBAK		;IF CURRENT CHR. WAS NULL,GET ANOTHER.
MVA:	CAIN TAC,11		;HAVE WE JUST ENCOUNTERED A TAB ?
	ADDI AC3,1		;YES.
	TRNN AC3,1		;ARE WE INSIDE A TAB ?
	JRST MVA1		; NO
	CAIN TAC,11		; YES, IS THIS A REAL TAB OR A LONG LINE CRLF?
	AOJA AC2,@(DSER)
	CAIN TAC," "
	JRST MVA2		; MUST BE A REAL TAB, SET THE BIT THAT SAYS SO
	SKIPE CHR		; IF WE ARE DELETING, WE MUST REPOSITION THE CRLF
	TLO J,NOBRBT		; DO SO BY PRETENDING THERE HAVEN'T BEEN ANY
	CAIE TAC,15		; BUMP COUNT ONE AT THE CR TO MAKE THE ENTIRE CRLF INVISIBLE
	JRST @(DSER)		; OTHERWISE, JUST LOOP AROUND
	TLNE J,XTABBT		; IF THIS IS A LONG LINE CRLF ONLY, THEN
	JRST @(DSER)
	SUBI AC1,1		; CORRECT COUNT
	AOJA AC2,@(DSER)

MVA1:	TLZ J,XTABBT
	AOJL AC1,@(DSER)	; COUNT DOWN RPT. CNT AND LOOP.
	JUMPE AC3,.+2		;ALL DONE. DID WE PASS ANY TABS ?
	TLZ J,TABB!NOTABB	;YES. WE NO LONGER KNOW WHERE NEXT ONE IS.
	SUB AC2,1(P)		;ADD NO. OF CHRS. PASSED TO NO. OF SPACES IN TABS PASSED.
	SUBB AC2,AC3		;SUB. 2⊗NO. OF TABS. THIS (MIRABILE DICTU!) GIVES NO. OF COLUMNS MOVED.
	JRST 1(DSER)

MVA2:	TLO J,XTABBT
	AOJA AC2,@(DSER)
;INIT2 INIT4 INIT4A INIT4B CRKILL

INIT2:	MOVE TAC,ACTMOD(DDB)	;GET SPECIAL BITS
	TLNN IOS,TPMON		;CAN'T SUPPRESS CTRL CR IN MONITOR MODE - ME 2/23/75
	TRNN TAC,SUPCCR		;SUPPRESS CTRL CR?
	CAIE CHR,1B28!15	;HAS LOSER TYPED CTRL1 CR ?
	JRST INITIT		;NO. RESET EVERYTHING FOR NEW LINE.
	SKIPN LEPNT1(J)		; HAVE WE INITIALIZED AT LEAST ONCE?
	JRST INITIT		; NO, DO SO NOW.
	PUSHJ P,QLETXT		; QUEUE UP A TRANSFER IF DD
INIT4:	HRLI J,400000!REEDBT!NOCRBT
	SETZM LCH(J)
;	JUMPGE UCHN,INIT4B
;	TLNE DAT,LERSEE
;	TLO J,SHLDRB		;POOLE MODE FLUSHED
				;LET LOSER EDIT PREVIOUS LINE SOME MORE.
INIT4B:	MOVEI UUO,2		;PREPARE TO REMOVE THE CR LF FROM END OF LINE.
INIT4A:	LDB TAC,LEPNT1(J)	;(WE DON'T WANT TO LET THE LOSER EDIT THEM. )
	MOVNI AC1,1		;TELL BACKSPACE ROUTINE TO DELETE ONE CHR.
	CAIE TAC,12		;IF IT IS A LF ...
	CAIN TAC,15		;... OR A CR ...
	PUSHJ P,CRKILL		;... THEN WE THROW IT OUT.
	SOJG UUO,INIT4A		;ALLOW FOR BOTH A LF AND A CR.
	DPB UUO,PLASTC
	TLZ J,NOTABB		;BS ROUTINE WILL HAVE SET THIS LOSER...
	SKIPN FCPOS(J)		;IS LINE EMPTY?
	TLO J,EOLBT		;YES, TELL SOMEONE PLEASE!!!!!
	SOJA P,INIT3		;RESET ONLY THE POINTER POSITION, AND RETURN UPLEVEL.

; THIS IS A ROUTINE FOR DELETING THE CRLF FROM THE END OF A LINE THAT
; WE GOT FROM PTLOAD OR <CTRL-1>CR.

CRKILL:	ADDM AC1,FCPOS(J)	; DECREMENT THE TOTAL NUMBER OF CHARACTERS IN THE BUFFER
	TLZ J,NOCRBT
	SETZ CHR,		; FLAG DELETING OPERATION TO MOVEIT
	PUSHJ P,MOVEIT		; BACK THE POINTER UP, DELETING THE CRLF AS IT GOES
	MVBAK			;Arg to subroutine
	MOVEM TAC1,LEPNT1(J)	; STORE THE UPDATED POINTER
	POPJ P,
;INITIT INIT3 INIT1

; THIS IS THE INITIALIZE ROUTINE. HERE WE INITIALIZE ALL THE LINE
; EDITOR VARIABLES

INITIT:	MOVEI TAC,EOLCHR*2+1	;GET DPY CHAR. WORD WITH LINE TERMINATING CHR. IN IT.
	MOVEM TAC,LEBUF(J)	;PLACE IN FIRST WORD OF BUFFER.
	MOVEI TAC,LEB(J)	; PUT RETURN JUMP IN SECOND WORD
	HRLI TAC,DISJMP
	MOVSM TAC,LEBUF+1(J)
	SETZM FCPOS(J)		;NO. OF CHARS. IN LINE.
	TLZ J,¬REEDBT		;REMEMBER IF IS RE-EDITED LINE (MAYBE DID A CLEAR)
	TLO J,EOLBT+400000
	SETZM LCH(J)
	MOVEI TAC,LEBUF(J)	;GET START OF LINE BUFFER.
	HRRZM TAC,LELWD(J)	;INIT. PTR. TO RETURN JMP.
INIT3:	SETZM LEHPOS(J)		;HORIZONTAL POSITION.
	SETZM NUMARG(J)		; CLEAR THE REPEAT ARGUEMENT
;ME	SETZM LESVCH(J)		; CLEAR THE CTRL-R ARGUMENT
	HLLM J,LETAB(DAT)	; STORE THE FLAG BITS BACK INTO THE LINE EDITOR TABLE
	SETZM CCPOS(J)		;CHARS. FROM START OF LINE.
	MOVE TAC,[LVW (12,-4,I,R,2,2)]
	MOVEM TAC,LEPPV(J)	;INITIAL POS. OF CURSOR.
	HRRZS LELMARG(J)	;RESET LEFT MARGIN.
INIT1:	HRLI TAC,440700		;MAKE INITIAL BYTE PTR.
	HRRI TAC,LEBUF(J)
	MOVEM TAC,LEPNT1(J)
	POPJ P,
;LACTIV ACTIV1 PTLLX ACTNH ACTNH0

↑LACTIV:TDZA UCHN,UCHN		;NO SPURIOUS CTRL BITS PLEASE.
PTLLX:	PUSHJ P,STLNAC		;SETUP LINE!
	TLNN LINE,DISLIN!DDDLIN!DMDLIN ;IF A DPY, XFER EDITOR BUFFER TO INPUT BUFFER NOW.
	POPJ P,			; IF NOT A DPY, RETURN NOW
	MOVE DAT,LINE
	SKIPGE J,LETAB(DAT)
	SKIPG CCPOS(J)
	POPJ P,			;NOTHING IN EDITOR BUFFER. FERGIT IT.
ACTIV1: JUMPGE J,CPOPJ		;POOLE AND HIS RECURSIVE CALLS ON ACTIV1 !
	TLC J,400000!WTFLAG	;READY FLAG OFF, WAIT FLAG ON.
	SETZ AC1,
	EXCH AC1,DPHOLD(J)
	JUMPE AC1,ACTNH		; IF NOT HOLDING, DON'T UNHOLD!
	HRRZ AC1,PRGNUM(J)	;GET TTY NUMBER
	HRLI AC1,UNHOLD
	CONO PI,PIOFF
	IDPB AC1,CLKQ
	CONO PI,PION
ACTNH:	AOJG UCHN,.+2		;IS PTYSER PRE-LOADING US WITH A LINE TO EDIT ?	
	PUSHJ P,INIT4		;YOU BETCHUM, R.R.  DON'T ACTIVATE GUY.
	PUSHJ P,INIT1		;RESET LEPNT1.
	MOVEM UCHN,NTABPT(J)	;SAVE CTRL BITS OF ACTIVATION CHR.
	MOVE TAC,FCPOS(J)	;MAKE COPY OF NO. OF CHRS. IN BUFFER.
	TLZN J,REEDBT		;IS THIS A RE-EDIT ?
	JRST ACTNH0
	DPB UCHN,[POINT 2,CHR,28]
	SUBI CHR,200
	DPB CHR,[POINT 9,GWORD(J),35]
	DPB TAC,PLASTC		;YES. REMEMBER LINE LENGTH.
;;;	MOVEI CHR,400
;;;	TLZE J,SHLDRB	;IS loser looking over our shoulder ?
;;;	PUSHJ P,LSRSEE	;Yes. Flag end of edit chrs.
ACTNH0:	MOVEM TAC,NTABCT(J)
	HLLM J,LETAB(DAT)	; STORE NEW STATUS.
	HRLI DAT,ACTIV3		;DO THE DIRTY WORK AT CLOCK LEVEL.
;	JRST DPYTIM
;PATCH BY RPH TO TRANSFER AS MANY CHARS AS WILL FIT IN
;TTY BUFFER NOW!!!!!! NOT LATER AT CLOCK LEVEL
	PUSH P,DAT		;SAVE LINE NUMBER
	PUSHJ P,ACTIV3		;CALL HIM ONCE
	POP P,DAT		;GET BACK LINE NUMBER
	MOVE J,LETAB(DAT)	;AND BITS
	POPJ P,			;AND RETURN TO WHO EVER
;ACTIV3 ACTIV4 ACTIV9 ACTIVL ACTIVM ACTIV6 ACTIVQ ACTIVR ACTIVS

;SET UP EVERYTHING AND GO BACK INTO LOOP.  MOVE LINED BUFFER TO TTY BUFFER
↑ACTIV3:HRRZ	LINE,DAT
	HLL	LINE,LINTAB(LINE)		;GET DISPLAY-TYPE BIT
	MOVE	J,LETAB(LINE)
	TLNE	LINE,DISLIN!DDDLIN!DMDLIN	;GOTTA BE A DISPLAY
	TLNN	J,WTFLAG			;SKIP IF TRANSFER IN PROGRESS
	POPJ	P,
	SKIPN	DDB,TTYTAB(DAT)
	JRST	ACTIV7			;SOMEBODY FLUSHED OUR DDB.  QUIT NOW.
ACTIV9:	MOVE	IOS,DEVIOS(DDB)
	MOVE	J,LETAB(LINE)
	MOVEI	UCHN,TTIBUF(DDB)	;GET POINTER FOR PUTCHI.
	HRRZ	DDB,J			;PICK UP ADDRESS OF DPY PROGRAM HEADER
	MOVE	TAC1,CURPP(J)		;POINTER TO PP BLOCK
	HLL	DDB,PPDPY(TAC1)		;GET DISPLAY-TYPE BIT FOR DPYTYO
	SKIPG	NTABCT(J)
	JRST	ACTIVR			;HERE IF E MODE 400 OVERFLOWED TTY BUFFER
	MOVEM	UCHN,DAT		;GIVE PUTCHI A PTR. TO INPUT BUFFER.
	MOVEI	TAC1,LEPNT1(J)		;TELL GETEM TO USE LEPNT1.
	LDB	CHR,(TAC1)		;AVOID FIRST ILDB!
	PUSHJ	P,GETEM0		;GET NEXT CHR. FROM BUFFER.
	JRST	ACTIVM

ACTIVL:	MOVEM UCHN,DAT		;GIVE PUTCHI A PTR. TO INPUT BUFFER.
	MOVEI TAC1,LEPNT1(J)	;TELL GETEM TO USE LEPNT1.
	PUSHJ P,GETEM		;GET NEXT CHR. FROM BUFFER.
ACTIVM:	PUSHJ P,PUTCHI		;PLACE CHAR. IN TTY INPUT BUFFER.
	JRST ACTIV2		;INPUT BUFFER FULL. WAIT A WHILE.
	SOSN CCPOS(J)		;IS THIS THE ACTIVATION CHAR. ?
	SOSG TAC,NTABPT(J)	;YES. DOES IT HAVE CTRL. BITS ?
	JRST ACTIV6		;NO.
	DPB TAC,[POINT 2,CHR,28]
				;YES. PUT CTRL. BITS IN INPUT BUFFER.
	DPB CHR,PUTR(DAT)
	MOVEI CHR,13		;ECHO CTRL. BITS, IF ANY.
	TRNE TAC,CBIT1
	PUSHJ P,ECHOCB
	MOVEI CHR,14	
	TRNE TAC,CBIT2
	PUSHJ P,ECHOCB
ACTIV6:	LDB CHR,LEPNT1(J)	;GET BACK DPY VERSION OF CHAR. CODE.
	PUSHJ P,ECHO		;ECHO IT ON PAGE PRINTER.
	TLNN DDB,DDDLIN		;DATA DISC?
	JRST ACTIVQ		;NO
	LDB CHR,LEPNT1(J)	;GET LAST CHR PUT OUT
	CAIN CHR,177		;IS IT A BS
	PUSHJ P,ECHO		;YES, ECHO TWICE FOR DD
ACTIVQ:	SOSLE NTABCT(J)		;ALL CHRS. XFERED ?
	JRST ACTIVL		;NO
	MOVEI TAC,EMODE		;ARE WE IN E MODE?
	MOVEI DDB,-TTIBUF(UCHN)	;WHY DON'T WE HAVE DDB SET UP GRUMBLE GRUMBLE
	TLNN IOS,TPMON		;NO EMODE IN MONITOR MODE
	TDNN TAC,ACTMOD(DDB)
	JRST ACTIVS		;NOT E MODE
ACTIVR:	MOVEM UCHN,DAT
	MOVEI CHR,400		;YES, FLAG END OF ACTIVATED TEXT
	PUSHJ P,PUTCHI		;PUT 400 INTO INPUT BUFFER
	 JRST ACTIV2		;INPUT BUFFER FULL, GET BACK HERE BY SEEING NTABCT≤0
;HERE WHEN THE LINE EDITOR BUFFER IS EMPTY.  CLEAN UP AND LEAVE.
ACTIVS:	MOVEI DDB,LEB(J)	; YES, MAKE EDITOR BUFFER INVISIBLE BY PUTTING
	HRLI DDB,DISJMP		; A RETURN JUMP ON TOP OF THE POSITION VECTOR
	MOVSM DDB,LEPPV(J)
	HRLI J,0		;RESET STATUS BITS.
	TLZ IOS,SYNC!DDTM	;DONT SCREW UP THE COUNT
ACTIV4:	MOVEI DDB,-TTIBUF(UCHN)	;RECOVER DDB.
	PUSHJ P,STLNAC		;SET UP LINE.
	HLLM J,LETAB(LINE)	;RESET STATUS. 
	PUSH P,TISYNC(DDB)	;REMEMBER CURRENT ACTIVATION COUNT!
	PUSHJ P,SYNCHK		;UPDATE TISYNC
	POP P,TAC		;GET BACK ORIGINAL COUNT
	CAMGE TAC,TISYNC(DDB)	;DID SYNCHK ACTIVATE SOME MORE CHARS?
	JRST RECIN3		;YES, WAKE COMMAND DECODER!
	JRST RECIN4
;ACTIV2 ACTIV7 ACTIV8 ACTI10

ACTIV2:	TLO IOS,SYNC!DDTM	;FORCE ACTIVATION
	PUSHJ P,ACTIV4		;GO ACTIVATE JOB.
	MOVE TAC,TTYTAB(LINE)
	TLNN TAC,400000		;DOES HE ALREADY HAVE A COMMAND WAITING?
	PUSHJ P,COMSET		;NO, SET HIM
	MOVE DAT,LINE
	POPJ P,

; WE GET HERE IF THE DDB HAS BEEN EATEN FROM UNDERNEATH US
; WE TRY TO GET HIM A NEW DDB.

ACTIV7:
;	CONO PI,SCNOFF
	OFFSCN				;TURN OFF SCANNER CHANNEL
	SKIPE DDB,TTYTAB(DAT)	; SEE IF IT IS REALLY GONE?
	JRST ACTIV8		; NOT REALLY, GO TO IT
	PUSHJ P,DDBSRC		; GET HIM A DDB
	JRST ACTI10		; NONE AVAILABLE, REPLANT CLOCK REQUEST AND WAIT
;	CONO PI,SCNON
	ONSCN				;TURN ON SCANNER CHANNEL
	JRST ACTIV9

ACTIV8:
;	CONO PI,SCNON
	ONSCN				;TURN ON SCANNER CHANNEL
	JRST ACTIV9

ACTI10:
;	CONO PI,SCNON
	ONSCN				;TURN ON SCANNER CHANNEL
	JRST DPYTIM
;ECHOCB ECHO SHIFT SHIFTR SHIFTL

ECHOCB:	TRNN IOS,NOECHB		;IS USER SUPPRESSING ECHO OF CTRL. BITS ?
	TRNE IOS,NOECHO		;OR ALL CHARS?
	TLNE IOS,TPMON		;YES, MONITOR GETS THEM ANYWAY
	JRST DPYTYO		;ECHO BIT
	POPJ P,

ECHO:	TLNE IOS,TPMON		; ALWAYS ECHO IN MONITOR MODE
	JRST DPYTYO
	TRNE IOS,NOECHO		;IS USER SUPPRESSING ALL ECHOING ?
	POPJ P,
	MOVE AC1,LCH(J)
	MOVEM CHR,LCH(J)
	CAIN CHR,12
	CAIE AC1,15
	JRST DPYTYO
	HRRZ AC1,PRGNUM(J)	; PICK UP TTY NUMBER
	MOVE AC1,LINTAB(AC1)	; FILL IN LINE CHARACTERISTICS
	TLNN AC1,XON		; LET THE LOSER TURN OFF LF AFTER CR IF HE WANTS TO
	JRST DPYTYO
	POPJ P,

SHIFT:	JUMPG DSER,SHIFTL	;OVER LEFT MARGIN ?
SHIFTR:	SKIPA AC2,.+1		;SHIFT LINE RIGHT.
SHIFTL:	MOVNI AC2,30		;SHIFT LINE LEFT.
	SKIPN III(J)		; ARE WE A DD OR DM DISPLAY?
	POPJ P,			;YES, DON'T SHIFT LINE 'CAUSE IT SCREWS UP DPHPOS
	HRRES DSER,AC2
	IMUL AC2,XDEL
	ADDM AC2,LELMARG(J)	;MOVE WHOLE LINE OVER.
	JRST SHIFT2		;SEE THE HAPPY RECURSIVE EDITOR !
;PTL7W9 PTLLED (PTLOAD) EPTL1 EPTL2 PTLL0 PTLL2 PTLL3 PTLL4 PTLL09 PTLLX0 PTLLX1 PTLLX9

↑PTL7W9:			;LOAD LINE EDITOR WITH 7-BIT STRING, THEN WRITE
	TDZA CHR,CHR		; A NINE BIT STRING ON TOP
↑PTLLED:			;PTLOAD UUO
	SETO CHR,		;FLAG A PLAIN PTLOAD UUO
	TLNE LINE,IMLIN
	JRST IMLOAD		;NOTICE THAT PTL7W9≡PTLOAD ON IMLACS!!
	TLNN LINE,DISLIN!DDDLIN!DMDLIN	;IF A DPY, PRELOAD THE LINE EDITOR
	POPJ P,
	SETZM PTLBUF
	MOVE TAC,[PTLBUF,,PTLBUF+1]
	BLT TAC,PTLBUF+PTLBUL-1	;CLEAR THE BUFFER BUFFER
	MOVE TAC,[POINT 9,PTLBUF]
	MOVEM TAC,PTLPTR	;USED TO STORE USER INPUT
	MOVEM TAC,PTLTKR
	JUMPN CHR,EPTL2		;JUMP IF PLAIN PTLOAD
	XCTR XR,[MOVE AC1,1(UUO)] ;GET PTR TO 9-BIT STRING OF "TYPE-AHEAD"
	TLNN AC1,-1		;BYTE POINTER YET?
	HRLI AC1,441100		;NOW IT IS
EPTL1:	XCTR XLB,[ILDB CHR,AC1]	;GET 9-BIT CHAR
	JUMPE CHR,EPTL2		;END WITH NULL
	PUSHJ P,PTLPUT		;SAVE CHAR FOR LATER
	JRST EPTL1

EPTL2:
;	CONO PI,SCNOFF		;COPY ANYTHING HE SNUCK IN FRONT INTO BUFFER
	OFFSCN				;TURN OFF SCANNER CHANNEL
PTLL0:	PUSHJ P,INCHGT
	MOVEI DAT,TTIBUF(DDB)
	PUSHJ P,GETCHY		;READ A CHAR
	JUMPE CHR,PTLL09	;NONE TO READ
	CAIN CHR,15		;IS IT A CR?
	JRST PTLL3		;YUP
PTLL4:	CAIE CHR,400		;DON'T BE FOOLED IF E MODE CONSES THIS UP
	PUSHJ P,PTLPUT		;PUT IN OUR BUFFER
	JRST PTLL0

PTLL3:	PUSHJ P,INCHGT		;get stuff from line editor if necessary
	MOVEI DAT,TTIBUF(DDB)
	PUSHJ P,GETCHY		;get input char, which better be a LF
	XORI CHR,15≠12		;CONVERT LF INTO A CR, WITH CONTROL BITS IN PLACE
	JRST PTLL4		;NOW STORE THE CR

PTLL09:	MOVSI IOS,PTLIP
	IORB IOS,DEVIOS(DDB)	;NO USER TYPEIN CAN INTERFERE WITH US NOW
;	CONO PI,SCNON
	ONSCN				;TURN ON SCANNER CHANNEL
	XCTR XR,[MOVE UUO,(UUO)]	;GET GUY'S PTR.
	TLNN UUO,-1		;IS IT ALREADY (PRESUMABLY) A BYTE PTR. ?
	HRLI UUO,440700		;NO. MAKE IT ONE.
PTLL2:	XCTR XLB,[ILDB CHR,UUO]	;GET CHR. FROM LOSER.
	MOVSI UCHN,-1		;FLAG TO KBDED SAYING IT'S US.
	JUMPE CHR,PTLLX0	;IF NULL, QUIT AND RESET EDITOR.
	PUSHJ P,STLNAC
	PUSHJ P,KBDED
	TRNN UCHN,1		;DID KBDED SEE AN ACTIVATION CHR. ?
	JRST PTLL2		;NO. 
PTLLX1:
;	CONO PI,SCNOFF
	OFFSCN				;TURN OFF SCANNER CHANNEL
	ILDB CHR,PTLTKR
	JUMPE CHR,PTLLX9	;NO BUFFERED CHARS LEFT TO TRANSFER
;	CONO PI,SCNON
	ONSCN				;TURN ON SCANNER CHANNEL
	LDB UCHN,[POINT 2,CHR,28]
	CAIN CHR,600
	MOVEI UCHN,0		;NO BUCKY BITS WANTED IN UCHN FOR CALL
	MOVEI DSER,(CHR)
	ANDI DSER,177		;MORE KBDED SETUP
	PUSHJ P,STLNAC
	PUSHJ P,KBDED
	JRST PTLLX1

PTLLX9:	MOVSI IOS,PTLIP		;TURN OFF PTLOAD MODE
	ANDCAB IOS,DEVIOS(DDB)
;	CONO PI,SCNON
	ONSCN				;TURN ON SCANNER CHANNEL
	POPJ P,

PTLLX0:	PUSHJ P,PTLLX
	JRST PTLLX1
;QLECUR QLETXT QLETX2

; HERE IS WHERE WE QUEUE UP LINE EDITOR TRANSFERS

QLETX2:
IFN FTINCL,<
	MOVE AC1,PRGNUM(J)	;Here only from main LINED outer routine KBDX1
	TLNN J,DMDAMN		;Extra hard case here
	TLNN AC1,DMLIN
	JRST QLETXT		;Not DM or too hard for now
	TLZE J,DMHARD		;Is this a hard DM xfer?
	SKIPN NCRS(J)		;Yes, but are there multiple lines in LE?
	JRST QLECUR		;No, trivial
>;FTINCL
↑↑QLETXT:
	SETOM LETXC(J)		; NOTE THAT TEXT HAS CHANGED and must be redrawn
	MOVE AC1,PRGNUM(J)	;Get display bit or DD channel in LH
	MOVEI AC2,DMLEPT(J)	;Address of DM queue to flush if DM
	TLNE AC1,DMLIN
	PUSHJ P,DMFLUS		;Flush DM's LE queue since we need to redraw line
QLECUR:	SKIPE III(J)		; IF III, THIS IS IRRELEVANT
	POPJ P,
	SETO AC2,		; TEST THE FLAG
	EXCH AC2,LECLK(J)	; IS THERE A CLOCK REQUEST ALREADY IN?
	JUMPL AC2,CPOPJ		; IF SO, HE WILL GET IT.
	HRR AC1,J		; IF NOT, MAKE UP ONE WITH THE DPY HEADER ADDRESS IN IT
	HRLI AC1,DPLED		; AND USE THE LINE EDITOR ROUTINE
	CONO PI,PIOFF
	IDPB AC1,CLKQ
	CONO PI,PION
	POPJ P,
;MAKECR LEFIX MAKEC1

; THIS IS A ROUTINE THAT GOES THROUGH THE LINE AND SETS UP EXTRA CRLFS TO BREAK
; LONG LINES.

MAKECR:	TLZ J,TABB!NOTABBT	; NEXT TAB IS UNKNOWN NOW
	TLNE J,400000		; IS IT REALLY THERE?
	SKIPE III(J)
	POPJ P,			; NOT THERE OR III
↑↑LEFIX:SETZ AC3,
	MOVE AC2,CURPP(J)	; PICK UP PAGE PRINTER CONTROL BLOCK ADDRESS
	MOVE AC1,PPHPOS(J)
	SUB AC1,LNLNGT(AC2)	;ROOM LEFT TO END OF LINE
	HRLI TAC,440700		; PICK UP BYTE POINTER TO BEGINNING OF BUFFER
	HRRI TAC,LEBUF(J)
	SETZM NCRS(J)		; INITIALIZE THE TRANSFER LENGTH COUNTER
MAKEC1:	ILDB CHR,TAC		; PICK UP CHARACTER
	JUMPE CHR,.-1		; SKIP NULLS
	CAIN CHR,EOLCHR		; IF END OF BUFFER,
	JRST MAKEC6		; LEAVE
	CAIN CHR,11		; IS THIS A TAB?
	JRST MAKEC2		; YES, IT IS, GO PROCESS IT
	AOJL AC1,MAKEC7		; NORMAL CHARACTER, BUMP COLUMN COUNT
;MAKE12 MAKE23 MAKE22 MAKE20 MAKE21 MAKEC8 MAKEC9 MAKEC7 MAKE10 MAKE24

; WE GET HERE IF THE LINE IS LONG AND MUST BE BROKEN UP.

MAKE12:	MOVE AC1,TAC		; PICK UP BYTE POINTER
MAKE23:	ILDB CHR,AC1		; LOOK AHEAD SOME
	JUMPE CHR,.-1
	CAIE CHR,11		; MAYBE THIS IS JUST THE LONG-LINE CRLF?
	JRST MAKE20		; APPARANTLY NOT, BUMP CR COUNT
	ILDB CHR,AC1		; PICK UP NEXT CHARACTER
	JUMPE CHR,.-1
	CAIE CHR,15		; IF THIS IS A CR, IS DEFINITELY A LONG-LINE CRLF
	JRST MAKE21
MAKE22:	ILDB CHR,AC1		; IN WHICH CASE, READ PAST IT
	CAIE CHR,11
	JRST MAKE22
	JRST MAKE23

MAKE20:	CAIE CHR,EOLCHR		; IF THERE ARE NO MORE CHARACTERS ON NEXT LINE, DON'T BUMP LINE COUNT
MAKE21:	AOS NCRS(J)		; END OF LINE, BREAK THE LINE UP
	TLNE DAT,DMLIN
	JRST MAKE24		; DMs don't need the long line CRLF
	MOVEI CHR,11		; END OF LINE, BREAK LINE
	PUSHJ P,MAKINS
	MOVEI CHR,15
	PUSHJ P,MAKINS
	MOVEI CHR,12
	PUSHJ P,MAKINS
	MOVEI CHR,11
	PUSHJ P,MAKINS
MAKE24:	MOVN AC1,LNLNGT(AC2)	; RESET COLUMN COUNT
MAKEC8:	MOVE TAC1,TAC		; SAVE POINTER
MAKEC9:	ILDB CHR,TAC1		; IS NEXT CHARACTER A NULL?
	JUMPN CHR,MAKEC7	; NO, ALL OK
	MOVE TAC,TAC1		; YES, SPACE POINTER OUT PAST NULLS
	JRST MAKEC9

MAKEC7:	ADDI AC3,1		; BUMP COLUMN COUNT
MAKE10:	CAMN AC3,CCPOS(J)	; IS THIS WHERE THE POINTER IS SUPPOSED TO BE?
	MOVEM TAC,LEPNT1(J)	; YES, STORE IT
	JRST MAKEC1
;MAKEC2 MAKEC6 MAKE17 MAKE18

; HERE WE SEE IF THE TAB IS A REAL TAB OR IF IT IS JUST
; THE THING WE USE TO DELIMIT A LONG-LINE CRLF

MAKEC2:	MOVE TAC1,TAC		; SAVE BYTE POINTER
	ILDB CHR,TAC		; PICK UP NEXT CHARACTER
	CAIE CHR,15		; IS IT A CR?
	JRST MAKEC3		; NO, MUST BE REGULAR TAB, GO ADJUST IT
	SETZ DSER,
	DPB DSER,TAC1		; YES, ZERO OUT THE LONG LINE CRLF
	DPB DSER,TAC
	IDPB DSER,TAC
	IDPB DSER,TAC
	JRST MAKE10

MAKEC6:	SETZ CHR,		; ZERO OUT STUFF AFTER END OF LINE CHARACTER
MAKE17:	LDB TAC1,[POINT 6,TAC,5]
	CAIG TAC1,7		; IS THERE ANY MORE ROOM IN THE LAST TEXT WORD
	JRST MAKE18		; NO, SET UP LELWD AND LEAVE
	IDPB CHR,TAC		; YES, PLOP DOWN A ZERO THERE
	JRST MAKE17

MAKE18:	HRRZ TAC1,TAC		; GET BARE ADDRESS OF LAST TEXT WORD IN BUFFER
	EXCH TAC1,LELWD(J)	; STORE IT AND GET THE OLD VALUE
	MOVE AC1,1(TAC1)	; PICK UP THE RETURN JUMP
	MOVEM AC1,1(TAC)	; PUT IT RIGHT AFTER THE END OF LINE CHARACTER
	POPJ P,
;MAKEC3 MAKEC4 MAKE16

; WE GET HERE WHEN THE TAB SURROUNDS A BUNCH OF SPACES. FIRST WE
; DELETE THE ORIGINAL SPACES, THEN WE FIGURE OUT HOW MANY WE NEED
; TO MAKE THE TAB COME OUT RIGHT AND PUT THEM IN.

MAKEC3:	PUSH P,AC3		; SAVE BYTE POINTER
	PUSH P,UUO		; GET AN ACCUMULATOR FOR COUNTING SPACES IN TABS
	SETZB DSER,UUO
MAKEC4:	DPB DSER,TAC		; ZERO OUT THE SPACES IN THE TAB
	CAIN CHR," "		; COUNT IT AS A SPACE ONLY IF IT REALY IS A SPACE
	ADDI UUO,1		; BUMP NUMBER OF SPACES IN THIS TAB
	ILDB CHR,TAC
	CAIE CHR,11		; UNTIL WE GET TO THE TERMINATING TAB
	JRST MAKEC4
	MOVE TAC,NCRS(J)	; FIGURE OUT POSITION FROM BEGINNING OF FIRST LINE
	ADDI TAC,1		; BUMP BY ONE TO CORRECT FOR NEGATIVITY OF AC1
	IMUL TAC,LNLNGT(AC2)	; MULTIPLY NUMBER OF LINES BY LENGTH OF LINES
	ADD TAC,AC1		; ADD IN CHARACTERS INTO LAST LINE
	MOVEM TAC,LECHPS(J)	; SAVE FOR FUTURE REFERENCE
IFN FTDM,<
	MOVN AC3,PPHPOS(J)	; DD/DM bug fix for improper cursor positioning
	ADDM AC3,LECHPS(J)	; PPHPOS was counted in NCRS but not in LEHPOS
>;
	ANDI TAC,7		; MOD 10
	MOVEI AC3,10
	SUB AC3,TAC		; THIS IS NUMBER OF COLUMNS TO GO
	ADD AC1,AC3		; ADD LENGTH OF TAB INTO COLUMN POSITION
	SUBM AC3,UUO		; GET CORRECTION TO THIS TAB
	JUMPLE AC1,MAKE13	; IF NOT AT END OF LINE, GO ON AND ADJUST TAB
	MOVE TAC,TAC1		; GET POINTER TO TAB
	MOVEI CHR," "		; NOW SPACE OUT TO END OF LINE
MAKE16:	CAML AC1,AC3		; OUT FAR ENOUGH?
	JRST MAKE15		; YES, PUT IN CRLF NOW
	PUSHJ P,MAKINS		; NO, PUT IN ANOTHER SPACE
	SOJA AC3,MAKE16
;MAKE15 MAKE13 MAKE14 MAKEC5

; AT THIS POINT, WE ARE IN THE PROCESS OF BREAKING A LONG LINE
; IN THE MIDDLE OF A TAB. WE HAVE JUST INSERTED THE APROPRIATE
; NUMBER OF SPACES TO FILL OUT THE LAST LINE, AND NOW WE
; MUST INSERT THE CRLF ITSELF.

MAKE15:	MOVEI CHR,15
	PUSHJ P,MAKINS		; BREAK LINE IN THE MIDDLE OF A TAB
	MOVEI CHR,12
	PUSHJ P,MAKINS
	AOS NCRS(J)		; UPDATE NUMBER OF CRLFS IN LINE
	MOVE TAC1,TAC		; SAVE BYTE POINTER TO TAB
	MOVE AC3,AC1		; NUMBER OF SPACES IS NUMBER OF CHARACTERS INTO LINE
	SUB AC1,LNLNGT(AC2)	; RESET COLUMN COUNT
MAKE13:	MOVE TAC,LECHPS(J)	; PICK UP NUMBER OF CHARACTERS FROM FIRST LINE
	CAMGE TAC,LEHPOS(J)	; ARE WE BEFORE THE HORIZONTAL POSITION POINTER?
	ADDM UUO,LEHPOS(J)	; YES, UPDATE IT
MAKE14:	POP P,UUO
	MOVE TAC,TAC1		; GET BYTE POINTER BACK
	MOVEI CHR,40
	PUSHJ P,MAKINS		; INSERT THAT MANY SPACES
	SOJG AC3,.-1
	LDB CHR,TAC		; NOW UPDATE POINTER TO PAST TAB
MAKEC5:	CAIN CHR,11
	JRST MAKE11		; THEN GET BACK INTO THE LOOP
	ILDB CHR,TAC		; NOT TAB, GET NEXT CHARACTER
	JRST MAKEC5
;MAKE11 MAKINS

MAKE11:	POP P,AC3		; RESTORE COLUMN COUNT
	JUMPGE AC1,MAKE12	; IF WE GOT LINE OVERFLOW, BREAK LINE UP
	JRST MAKEC8

MAKINS:	ILDB TAC1,TAC		; IS THIS CHARACTER A NULL?
	JUMPE TAC1,.+2
	PUSHJ P,LEINSW		; NO, INSERT A WORD OF NULLS
	DPB CHR,TAC		; DEPOSIT OUR CHARACTER OVER A NULL
	POPJ P,
;PUTDMC GETLEQ QUODMC PUTDM2 QU2DMC QU2DM2 QU2DM3

IFN FTDM,<

;Here to put out quoted line editor char which must be followed in same queue
;entry by 1 or 2 other chars.
↑QU2DMC:
	MOVEI AC2,4		;Make sure at least room for 4 chars
	HLRZ AC1,DMLEPT(J)	;Get pointer to end of LE queue
	CAIE AC1,DMLEPT-QLINK(J);Is queue empty?
	CAMLE AC2,QFREE(AC1)	;No, less than 4 bytes of room left?
	JRST QU2DM2		;Yes to one of these, get a new queue entry
	JRST QU2DM3		;No, just do it

;Here to put out a quoted line editor character.
;Make sure room in queue entry for two chars.
↑↑QUODMC:
	HLRZ AC1,DMLEPT(J)	;Get pointer to end of LE queue
	CAIE AC1,DMLEPT-QLINK(J);Is queue empty?
QU2DM3:	SOSG QFREE(AC1)		;No, less than two bytes of room left?
QU2DM2:	PUSHJ P,GETLEQ		;Yes to one of these, get a new queue entry
	SOS QFREE(AC1)		;Count another byte used up for the 177
	MOVEI AC2,177
	IDPB AC2,QPUTR(AC1)	;Quote the next char
	AOS QDMCNT(AC1)		;Count the 177
	JRST PUTDM2
	
;Routine to place a LE output char in DM's LE queue.
;Scanner channel must be off (if not in it now). (This is true of LINED in general.)
↑PUTDMC:
	HLRZ AC1,DMLEPT(J)	;Get pointer to end of LE queue
	CAIE AC1,DMLEPT-QLINK(J);Is queue empty?
	SOSGE QFREE(AC1)	;No, is last queue entry full?
	PUSHJ P,GETLEQ		;Yes to one of these, get a new queue entry
PUTDM2:	IDPB CHR,QPUTR(AC1)	;Insert new char
	AOS QDMCNT(AC1)		;Count another to take out
	POPJ P,

;Routine to set up an empty queue entry in DM's LE queue.
;Called from PUTDMC (above) and DMLED (in DPYSER).
↑↑GETLEQ:
	PUSHJ P,GETQ
	MOVEI AC2,QTEXTL*5-1	;Amount of room in queue entry for text, less 1 char
	MOVEM AC2,QFREE(AC1)
	MOVEI AC2,QTEXT(AC1)
	HRLI AC2,440700
	MOVEM AC2,QTAKR(AC1)	;Byte pointer for unpacking LE text
	MOVEM AC2,QPUTR(AC1)	;Byte pointer for storing LE text
	SETZM QDMCNT(AC1)	;No chars in queue entry yet
	HRLM J,QFLAGS(AC1)	;Put pointer to dpy hdr into queue entry
	MOVEI AC2,DMLEXY(J)
	MOVEM AC2,QXYLOC(AC1)	;Store address of X-Y position word
	MOVSI AC2,DPLED
	HRR AC2,J		;Pass dpy header address
	MOVEM AC2,QWAKE(AC1)
	MOVEI AC2,LEENQ(J)
	MOVEM AC2,QCOUNT(AC1)
	AOS LEENQ(J)
	MOVEI AC2,DMLEPT-QLINK(J) ;Queue header address
	JRST QDM		;Now queue it
>;FTDM

BEND LINED
BEND   TTYSER